ErogazioniApiHelper.java

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

  22. import static org.openspcoop2.utils.service.beans.utils.BaseHelper.deserializeDefault;
  23. import static org.openspcoop2.utils.service.beans.utils.BaseHelper.evalnull;

  25. import java.util.ArrayList;
  26. import java.util.Arrays;
  27. import java.util.Date;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.Optional;
  32. import java.util.Properties;
  33. import java.util.stream.Collectors;
  34. import java.util.stream.Stream;

  36. import javax.ws.rs.core.UriInfo;

  38. import org.apache.commons.lang.StringEscapeUtils;
  39. import org.apache.commons.lang3.StringUtils;
  40. import org.openspcoop2.core.commons.CoreException;
  41. import org.openspcoop2.core.commons.Filtri;
  42. import org.openspcoop2.core.commons.Liste;
  43. import org.openspcoop2.core.config.AttributeAuthority;
  44. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  45. import org.openspcoop2.core.config.AutorizzazioneScope;
  46. import org.openspcoop2.core.config.Configurazione;
  47. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  48. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  49. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  50. import org.openspcoop2.core.config.CorsConfigurazione;
  51. import org.openspcoop2.core.config.DumpConfigurazione;
  52. import org.openspcoop2.core.config.DumpConfigurazioneRegola;
  53. import org.openspcoop2.core.config.GestioneToken;
  54. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  55. import org.openspcoop2.core.config.InvocazioneServizio;
  56. import org.openspcoop2.core.config.PortaApplicativa;
  57. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneToken;
  58. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  59. import org.openspcoop2.core.config.PortaDelegata;
  60. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneToken;
  61. import org.openspcoop2.core.config.PortaDelegataAzione;
  62. import org.openspcoop2.core.config.PortaTracciamento;
  63. import org.openspcoop2.core.config.Proprieta;
  64. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  65. import org.openspcoop2.core.config.ResponseCachingConfigurazioneHashGenerator;
  66. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  67. import org.openspcoop2.core.config.Ruolo;
  68. import org.openspcoop2.core.config.ServizioApplicativo;
  69. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  70. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  71. import org.openspcoop2.core.config.constants.CorrelazioneApplicativaGestioneIdentificazioneFallita;
  72. import org.openspcoop2.core.config.constants.CorrelazioneApplicativaRichiestaIdentificazione;
  73. import org.openspcoop2.core.config.constants.CorrelazioneApplicativaRispostaIdentificazione;
  74. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  75. import org.openspcoop2.core.config.constants.PortaDelegataSoggettiErogatori;
  76. import org.openspcoop2.core.config.constants.RuoloContesto;
  77. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  78. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  79. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  80. import org.openspcoop2.core.config.constants.StatoFunzionalitaCacheDigestQueryParameter;
  81. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  82. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  83. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  84. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  85. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  86. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  87. import org.openspcoop2.core.config.rs.server.api.impl.Enums;
  88. import org.openspcoop2.core.config.rs.server.api.impl.Environment;
  89. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  90. import org.openspcoop2.core.config.rs.server.api.impl.HttpRequestWrapper;
  91. import org.openspcoop2.core.config.rs.server.api.impl.IdServizio;
  92. import org.openspcoop2.core.config.rs.server.api.impl.StatoDescrizione;
  93. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.configurazione.ErogazioniConfEnv;
  94. import org.openspcoop2.core.config.rs.server.api.impl.fruizioni.configurazione.FruizioniConfEnv;
  95. import org.openspcoop2.core.config.rs.server.config.LoggerProperties;
  96. import org.openspcoop2.core.config.rs.server.model.*;
  97. import org.openspcoop2.core.constants.CostantiConnettori;
  98. import org.openspcoop2.core.constants.CostantiDB;
  99. import org.openspcoop2.core.constants.TipiConnettore;
  100. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  101. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  102. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyRaggruppamento;
  103. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  104. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  105. import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
  106. import org.openspcoop2.core.controllo_traffico.constants.TipoPeriodoRealtime;
  107. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsa;
  108. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  109. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  110. import org.openspcoop2.core.id.IDAccordo;
  111. import org.openspcoop2.core.id.IDFruizione;
  112. import org.openspcoop2.core.id.IDPortaApplicativa;
  113. import org.openspcoop2.core.id.IDPortaDelegata;
  114. import org.openspcoop2.core.id.IDRuolo;
  115. import org.openspcoop2.core.id.IDServizio;
  116. import org.openspcoop2.core.id.IDSoggetto;
  117. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  118. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  119. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  120. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  121. import org.openspcoop2.core.registry.ConfigurazioneServizio;
  122. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  123. import org.openspcoop2.core.registry.Connettore;
  124. import org.openspcoop2.core.registry.Documento;
  125. import org.openspcoop2.core.registry.Fruitore;
  126. import org.openspcoop2.core.registry.IdSoggetto;
  127. import org.openspcoop2.core.registry.Property;
  128. import org.openspcoop2.core.registry.Soggetto;
  129. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  130. import org.openspcoop2.core.registry.beans.GruppoSintetico;
  131. import org.openspcoop2.core.registry.beans.PortTypeSintetico;
  132. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  133. import org.openspcoop2.core.registry.constants.PddTipologia;
  134. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  135. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  136. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  137. import org.openspcoop2.core.registry.constants.ServiceBinding;
  138. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  139. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  140. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  141. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  142. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  143. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  144. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  145. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  146. import org.openspcoop2.core.registry.driver.db.IDAccordoDB;
  147. import org.openspcoop2.core.registry.driver.db.IDSoggettoDB;
  148. import org.openspcoop2.core.transazioni.utils.TipoCredenzialeMittente;
  149. import org.openspcoop2.pdd.config.UrlInvocazioneAPI;
  150. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneApiKey;
  151. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneBasic;
  152. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazionePrincipal;
  153. import org.openspcoop2.pdd.core.autorizzazione.CostantiAutorizzazione;
  154. import org.openspcoop2.pdd.core.autorizzazione.canali.CanaliUtils;
  155. import org.openspcoop2.protocol.basic.Utilities;
  156. import org.openspcoop2.protocol.engine.constants.Costanti;
  157. import org.openspcoop2.protocol.information_missing.constants.StatoType;
  158. import org.openspcoop2.protocol.sdk.ProtocolException;
  159. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  160. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  161. import org.openspcoop2.protocol.sdk.properties.AbstractProperty;
  162. import org.openspcoop2.protocol.sdk.properties.ConsoleConfiguration;
  163. import org.openspcoop2.protocol.sdk.properties.IConsoleDynamicConfiguration;
  164. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  165. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  166. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  167. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  168. import org.openspcoop2.protocol.utils.EsitiConfigUtils;
  169. import org.openspcoop2.protocol.utils.EsitiProperties;
  170. import org.openspcoop2.utils.BooleanNullable;
  171. import org.openspcoop2.utils.LoggerWrapperFactory;
  172. import org.openspcoop2.utils.UtilsException;
  173. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  174. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  175. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  176. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  177. import org.openspcoop2.utils.service.beans.utils.ListaUtils;
  178. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  179. import org.openspcoop2.web.ctrlstat.core.AutorizzazioneUtilities;
  180. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  181. import org.openspcoop2.web.ctrlstat.core.SerialiableFormFile;
  182. import org.openspcoop2.web.ctrlstat.costanti.ConnettoreServletType;
  183. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  184. import org.openspcoop2.web.ctrlstat.plugins.ExtendedConnettore;
  185. import org.openspcoop2.web.ctrlstat.plugins.servlet.ServletExtendedConnettoreUtils;
  186. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  187. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  188. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  189. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  190. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaUtilities;
  191. import org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni.ErogazioniCostanti;
  192. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCore;
  193. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  194. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneHelper;
  195. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  196. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  197. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeHelper;
  198. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeUtilities;
  199. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  200. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  201. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateUtilities;
  202. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  203. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCore;
  204. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  205. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  206. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  207. import org.openspcoop2.web.lib.mvc.ServletUtils;
  208. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  209. import org.slf4j.Logger;


  212. /**
  213.  * ErogazioniApiHelper
  214.  * 
  215.  * @author $Author$
  216.  * @version $Rev$, $Date$
  217.  */
  218. public class ErogazioniApiHelper {
  219.     
  220.     private ErogazioniApiHelper() {}
  221.         
  222.     
  223.     public static void validateProperties(ErogazioniEnv env, ProtocolProperties protocolProperties, AccordoServizioParteSpecifica asps,
  224.             ConsoleOperationType operationType)
  225.             throws Exception {
  226.         if(protocolProperties!=null) {
  227.             try{

  229.                 ConsoleConfiguration consoleConf = getConsoleConfiguration(env, asps);

  231.                 env.apsHelper.validaProtocolProperties(consoleConf, ConsoleOperationType.ADD, protocolProperties);
  232.                 
  233.                 IDServizio oldIdAps = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(), new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione()); 
  234.                 oldIdAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  235.                 oldIdAps.setPortType(asps.getPortType());
  236.                 
  237.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  238.                 IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  239.                 IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);
  240.                 consoleDynamicConfiguration.updateDynamicConfigAccordoServizioParteSpecifica(consoleConf, operationType, env.apsHelper, protocolProperties, 
  241.                         registryReader, configRegistryReader, oldIdAps);
  242.                 
  243.                 consoleDynamicConfiguration.validateDynamicConfigAccordoServizioParteSpecifica(consoleConf, operationType, env.apsHelper, protocolProperties, 
  244.                         registryReader, configRegistryReader, oldIdAps);
  245.                 
  246.             }catch(ProtocolException e){
  247.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(e);
  248.             }
  249.         }
  250.     }

  252.     public static void validateProperties(ErogazioniEnv env, ProtocolProperties protocolProperties, IDFruizione id,
  253.             ConsoleOperationType operationType)
  254.             throws Exception {
  255.         if(protocolProperties!=null) {
  256.             try{

  258.                 ConsoleConfiguration consoleConf = getConsoleConfiguration(env, id);

  260.                 env.apsHelper.validaProtocolProperties(consoleConf, ConsoleOperationType.ADD, protocolProperties);
  261.                 
  262.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  263.                 IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  264.                 IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);
  265.                 consoleDynamicConfiguration.updateDynamicConfigFruizioneAccordoServizioParteSpecifica(consoleConf, operationType, env.apsHelper, protocolProperties, 
  266.                         registryReader, configRegistryReader, id);
  267.                 
  268.                 consoleDynamicConfiguration.validateDynamicConfigFruizioneAccordoServizioParteSpecifica(consoleConf, operationType, env.apsHelper, protocolProperties, 
  269.                         registryReader, configRegistryReader, id);
  270.                 
  271.             }catch(ProtocolException e){
  272.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(e);
  273.             }
  274.         }
  275.     }


  278.     public static ConsoleConfiguration getConsoleConfiguration(ErogazioniEnv env, AccordoServizioParteSpecifica asps) throws Exception {
  279.         IDServizio oldIdAps = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(), new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione()); 
  280.         oldIdAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  281.         oldIdAps.setPortType(asps.getPortType());

  283.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  285.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  286.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  288.         env.requestWrapper.overrideParameter(Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VIA_PARAM, Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE);
  289.         
  290.         return consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteSpecifica(ConsoleOperationType.ADD, env.apsHelper, 
  291.                 registryReader, configRegistryReader, oldIdAps);

  293.     }
  294.     
  295.     public static void updateConsoleConfiguration(ErogazioniEnv env, AccordoServizioParteSpecifica asps,
  296.             ConsoleConfiguration consoleConf, ProtocolProperties prop) throws Exception {
  297.         IDServizio oldIdAps = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(), new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione()); 
  298.         oldIdAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  299.         oldIdAps.setPortType(asps.getPortType());

  301.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  303.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  304.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  306.         env.requestWrapper.overrideParameter(Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VIA_PARAM, Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE);
  307.         
  308.         consoleDynamicConfiguration.updateDynamicConfigAccordoServizioParteSpecifica(consoleConf, ConsoleOperationType.CHANGE, env.apsHelper, prop,
  309.                 registryReader, configRegistryReader, oldIdAps);

  311.     }

  313.     public static ConsoleConfiguration getConsoleConfiguration(ErogazioniEnv env, IDFruizione id) throws Exception {
  314.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  316.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  317.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  319.         env.requestWrapper.overrideParameter(Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VIA_PARAM, Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE);

  321.         return consoleDynamicConfiguration.getDynamicConfigFruizioneAccordoServizioParteSpecifica(ConsoleOperationType.ADD, env.apsHelper, registryReader, configRegistryReader, id);
  322.     }
  323.     
  324.     public static void updateConsoleConfiguration(ErogazioniEnv env, IDFruizione id,
  325.             ConsoleConfiguration consoleConf, ProtocolProperties prop) throws Exception {
  326.         
  327.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  329.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  330.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  332.         env.requestWrapper.overrideParameter(Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VIA_PARAM, Costanti.CONSOLE_PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE);
  333.         
  334.         consoleDynamicConfiguration.updateDynamicConfigFruizioneAccordoServizioParteSpecifica(consoleConf, ConsoleOperationType.CHANGE, env.apsHelper, prop,
  335.                 registryReader, configRegistryReader, id);

  337.     }


  340.     public static ProtocolProperties getProtocolProperties(AccordoServizioParteSpecifica asps, ErogazioniEnv env) throws Exception {
  341.         ConsoleConfiguration consoleConf = getConsoleConfiguration(env, asps);

  343.         ProtocolProperties prop = env.apsHelper.estraiProtocolPropertiesDaRequest(consoleConf, ConsoleOperationType.CHANGE);
  344.         ProtocolPropertiesUtils.mergeProtocolPropertiesRegistry(prop, asps.getProtocolPropertyList(), ConsoleOperationType.CHANGE);
  345.         
  346.         // update della configurazione
  347.         // non sembra servire
  348.         //updateConsoleConfiguration(env, asps, consoleConf, prop);
  349.         
  350.         return prop;
  351.     }
  352.     public static ProtocolProperties getProtocolProperties(IDFruizione id, Fruitore f, ErogazioniEnv env) throws Exception {
  353.         ConsoleConfiguration consoleConf = getConsoleConfiguration(env, id);

  355.         ProtocolProperties prop = env.apsHelper.estraiProtocolPropertiesDaRequest(consoleConf, ConsoleOperationType.CHANGE);
  356.         ProtocolPropertiesUtils.mergeProtocolPropertiesRegistry(prop, f.getProtocolPropertyList(), ConsoleOperationType.CHANGE);
  357.         
  358.         // update della configurazione 
  359.         // non sembra servire
  360.         //updateConsoleConfiguration(env, id, consoleConf, prop);
  361.         
  362.         return prop;
  363.     }
  364.     public static Map<String, AbstractProperty<?>> getProtocolPropertiesMap(AccordoServizioParteSpecifica asps, ErogazioniEnv env) throws Exception {

  366.         ProtocolProperties prop = getProtocolProperties(asps, env);
  367.         Map<String, AbstractProperty<?>> p = new HashMap<>();

  369.         for(int i =0; i < prop.sizeProperties(); i++) {
  370.             p.put(prop.getIdProperty(i), prop.getProperty(i));
  371.         }
  372.         
  373.         return p;
  374.     }
  375.     
  376.     public static Map<String, AbstractProperty<?>> getProtocolPropertiesMap(IDFruizione id, Fruitore f, ErogazioniEnv env) throws Exception {

  378.         ProtocolProperties prop = getProtocolProperties(id, f, env);
  379.         Map<String, AbstractProperty<?>> p = new HashMap<>();

  381.         for(int i =0; i < prop.sizeProperties(); i++) {
  382.             p.put(prop.getIdProperty(i), prop.getProperty(i));
  383.         }
  384.         
  385.         return p;
  386.     }
  387.     
  388.     public static ProtocolProperties getProtocolProperties(Erogazione body, ProfiloEnum profilo, AccordoServizioParteComune aspc, AccordoServizioParteSpecifica asps, ErogazioniEnv env, boolean required) throws Exception {


  391.         if(!profilo.equals(ProfiloEnum.MODI) && !profilo.equals(ProfiloEnum.MODIPA) && body.getModi() != null) {
  392.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione 'ModI' non conforme con il profilo '"+profilo+"' indicato");
  393.         }

  395.         switch(profilo) {
  396.         case APIGATEWAY:
  397.             return null;// trasparente 
  398.         case EDELIVERY:
  399.             return EDeliveryErogazioniApiHelper.getProtocolProperties(body);
  400.         case FATTURAPA:
  401.             return FatturaPAErogazioniApiHelper.getProtocolProperties(body);
  402.         case MODI:
  403.         case MODIPA:
  404.             return ModiErogazioniApiHelper.getProtocolProperties(body, aspc, asps, env, required);
  405.         case SPCOOP:
  406.             return SPCoopErogazioniApiHelper.getProtocolProperties(body);
  407.         }
  408.         return null;
  409.     }

  411.     public static ProtocolProperties getProtocolProperties(Fruizione body, ProfiloEnum profilo, AccordoServizioParteSpecifica asps, ErogazioniEnv env, boolean required) throws Exception {


  414.         if(!profilo.equals(ProfiloEnum.MODI) && !profilo.equals(ProfiloEnum.MODIPA) && body.getModi() != null) {
  415.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione 'ModI' non conforme con il profilo '"+profilo+"' indicato");
  416.         }

  418.         switch(profilo) {
  419.         case APIGATEWAY:
  420.             return null;// trasparente 
  421.         case EDELIVERY:
  422.             return EDeliveryErogazioniApiHelper.getProtocolProperties(body);
  423.         case FATTURAPA:
  424.             return FatturaPAErogazioniApiHelper.getProtocolProperties(body);
  425.         case MODI:
  426.         case MODIPA:
  427.             return ModiErogazioniApiHelper.getProtocolProperties(body, asps, env, required);
  428.         case SPCOOP:
  429.             return SPCoopErogazioniApiHelper.getProtocolProperties(body); 
  430.         }
  431.         return null;
  432.     }


  435.     @SuppressWarnings("unchecked")
  436.     public static final <T> T deserializeModalitaConfGruppo(ModalitaConfigurazioneGruppoEnum discr, Object body) throws UtilsException, InstantiationException, IllegalAccessException {
  437.         
  438.         switch(discr) {
  439.         case EREDITA: {
  440.             GruppoEreditaConfigurazione conf = deserializeDefault(body, GruppoEreditaConfigurazione.class);
  441.             if (StringUtils.isEmpty(conf.getNome())) {
  442.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(GruppoEreditaConfigurazione.class.getName()+": Indicare il campo obbligatorio 'nome'");
  443.             }
  444.             return (T) conf;
  445.         }
  446.         case NUOVA: {
  447.             GruppoNuovaConfigurazione conf = deserializeDefault(body, GruppoNuovaConfigurazione.class);
  448.             ErogazioniCheckNotNull.checkAutenticazione(conf);
  449.             
  450.             return (T) conf;
  451.         }
  452.         default: 
  453.             return null;
  454.         }
  455.     }

  457.     
  458.     public static final void fillAps(
  459.             AccordoServizioParteSpecifica specifico, 
  460.             APIImpl impl,
  461.             ErogazioniEnv env
  462.         ) throws ProtocolException {    
  463.         
  464.         specifico.setNome(impl.getApiNome());
  465.         
  466.         if(impl.getTipoServizio()!=null && StringUtils.isNotEmpty(impl.getTipoServizio())) {
  467.             List<String> l = env.protocolFactoryMgr.getProtocolFactoryByName(env.tipo_protocollo).createProtocolConfiguration().getTipiServizi(null);
  468.             if(l!=null && !l.contains(impl.getTipoServizio())) {
  469.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Tipo servizio indicato '"+impl.getTipoServizio()+"' non supportato dal profilo '"+env.profilo+"'");
  470.             }
  471.             specifico.setTipo(impl.getTipoServizio());
  472.         }
  473.         
  474.         specifico.setVersione(impl.getApiVersione());
  475.         specifico.setPortType(impl.getApiSoapServizio());   
  476.     }
  477.     
  478.     public static final AccordoServizioParteSpecifica apiImplToAps(APIImpl impl, final Soggetto soggErogatore, AccordoServizioParteComuneSintetico as, ErogazioniEnv env) 
  479.             throws DriverRegistroServiziException, ProtocolException {
  480.         final AccordoServizioParteSpecifica ret = new AccordoServizioParteSpecifica();
  481.                 
  482.         fillAps(ret, impl, env);
  483.         
  484.         // Questo per seguire la specifica della console, che durante la creazione di un servizio soap
  485.         // vuole che il nome del'asps sia quello del servizio\port_type
  486.         if (as.getServiceBinding() == ServiceBinding.SOAP) {
  487.             ret.setNome(ret.getPortType());
  488.         }
  489.         
  490.         if(env.apsCore.isSupportatoVersionamentoAccordiServizioParteSpecifica(env.tipo_protocollo))
  491.             ret.setVersione(as.getVersione());
  492.         
  493.         if(impl instanceof Erogazione) {
  494.             Erogazione erogazione = (Erogazione) impl;
  495.             if(erogazione.getErogazioneNome()!=null && !"".equals(erogazione.getErogazioneNome())) {
  496.                 ret.setNome(erogazione.getErogazioneNome());
  497.             }
  498.             if(env.apsCore.isSupportatoVersionamentoAccordiServizioParteSpecifica(env.tipo_protocollo) &&
  499.                 erogazione.getErogazioneVersione()!=null && erogazione.getErogazioneVersione()>0) {
  500.                 ret.setVersione(erogazione.getErogazioneVersione());
  501.             }
  502.             ret.setDescrizione(erogazione.getDescrizione());
  503.         }
  504.         else if(impl instanceof Fruizione) {
  505.             Fruizione fruizione = (Fruizione) impl;
  506.             if(fruizione.getFruizioneNome()!=null && !"".equals(fruizione.getFruizioneNome())) {
  507.                 ret.setNome(fruizione.getFruizioneNome());
  508.             }
  509.             if(env.apsCore.isSupportatoVersionamentoAccordiServizioParteSpecifica(env.tipo_protocollo) &&
  510.                 fruizione.getFruizioneVersione()!=null && fruizione.getFruizioneVersione()>0) {
  511.                 ret.setVersione(fruizione.getFruizioneVersione());
  512.             }
  513.             // descrizione deve essere impostata sul fruitore
  514.         }

  516.         ret.setIdSoggetto(soggErogatore.getId());
  517.         ret.setTipoSoggettoErogatore(soggErogatore.getTipo());
  518.         ret.setNomeSoggettoErogatore(soggErogatore.getNome());

  520.         ret.setVersioneProtocollo(soggErogatore.getVersioneProtocollo());
  521.         
  522.         ret.setByteWsdlImplementativoErogatore(null);
  523.         ret.setByteWsdlImplementativoFruitore(null);
  524.         
  525.         ret.setIdAccordo(as.getId());   
  526.         ret.setAccordoServizioParteComune(env.idAccordoFactory.getUriFromAccordo(as));
  527.         ret.setTipologiaServizio(TipologiaServizio.NORMALE); // dal debug servcorr è "no"
  528.         ret.setSuperUser(env.userLogin);
  529.         ret.setPrivato(false);                              // Come da debug.
  530.         ret.setStatoPackage(StatoType.FINALE.getValue()); 
  531.         ret.setConfigurazioneServizio(new ConfigurazioneServizio());
  532.                  
  533.         if (StringUtils.isEmpty(ret.getTipo())) {
  534.             String tipoServizio = env.protocolFactoryMgr.getProtocolFactoryByName(env.tipo_protocollo).createProtocolConfiguration().getTipoServizioDefault(Utilities.convert(as.getServiceBinding()));
  535.             ret.setTipo( tipoServizio );
  536.         }
  537.                 
  538.         return ret;
  539.     }
  540.     
  541.     
  542.     public static final void serviziUpdateCheckData(AccordoServizioParteComuneSintetico as, AccordoServizioParteSpecifica asps, boolean isErogazione, ErogazioniEnv env) throws Exception {
  543.         
  544.          // Determino i soggetti compatibili
  545.         ConsoleSearch searchSoggetti = new ConsoleSearch(true);
  546.         searchSoggetti.addFilter(Liste.SOGGETTI, Filtri.FILTRO_PROTOCOLLO, env.tipo_protocollo);
  547.         String[] soggettiCompatibili = env.soggettiCore.soggettiRegistroList(null, searchSoggetti).stream()
  548.                 .map( s -> s.getId().toString())
  549.                 .toArray(String[]::new);
  550.         
  551.         // Determino la lista Api
  552.         String[] accordiList = AccordiServizioParteSpecificaUtilities.getListaIdAPI(
  553.                 env.tipo_protocollo,
  554.                 env.userLogin,
  555.                 env.apsCore, 
  556.                 env.apsHelper
  557.             ).stream()
  558.             .map( a -> a.getId().toString() )
  559.             .toArray(String[]::new);
  560.         

  562.         // Determino l'erogatore
  563.         IdSoggetto erogatore = new IdSoggetto( new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()));
  564.         erogatore.setId(asps.getIdSoggetto());
  565.         
  566.         org.openspcoop2.core.registry.Connettore connRegistro = asps.getConfigurazioneServizio().getConnettore();
  567.         
  568.         final String endpointtype = connRegistro.getTipo();
  569.         final String endpoint_url = connRegistro.getProperties().get(CostantiDB.CONNETTORE_HTTP_LOCATION);
  570.         
  571.         // Recupero i Servizi Esposti dalla API 
  572.         final String[] ptArray =  AccordiServizioParteSpecificaUtilities.getListaPortTypes(as, env.apsHelper)
  573.                 .stream()
  574.                 .map( p -> p.getNome() )
  575.                 .toArray(String[]::new);
  576.         
  577.         final boolean accordoPrivato = as.getPrivato()!=null && as.getPrivato();

  579.         final ConnettoreHttp connRest = new ConnettoreHTTPApiHelper().buildConnettore(connRegistro.getProperties(), connRegistro.getTipo());
  580.         final ConnettoreConfigurazioneApiKey httpApiKey = connRest.getAutenticazioneApikey();
  581.         boolean apiKey = (httpApiKey!=null && httpApiKey.getApiKey()!=null && StringUtils.isNotEmpty(httpApiKey.getApiKey()));
  582.         final ConnettoreConfigurazioneHttps httpsConf    = connRest.getAutenticazioneHttps();

  584.         final ConnettoreConfigurazioneHttpBasic httpConf     = connRest.getAutenticazioneHttp();
  585.         // Questa è la cosa diversa per i fruitori, Li invece abbiamo le credenziali direttamente nel connettore.
  586.         final ConnettoreConfigurazioneHttpsClient httpsClient = httpsConf!=null ? evalnull( httpsConf::getClient ) : null;
  587.         final ConnettoreConfigurazioneHttpsServer httpsServer = httpsConf!=null ? evalnull( httpsConf::getServer ) : null;
  588.         final ConnettoreConfigurazioneProxy       proxy       = connRest.getProxy();
  589.         final ConnettoreConfigurazioneTimeout     timeoutConf = connRest.getTempiRisposta();
  590.         final String tokenPolicy = connRest.getTokenPolicy(); 
  591.         final boolean autenticazioneToken = tokenPolicy!=null;
  592.         
  593.         
  594.         final boolean httpsstato = httpsClient != null;
  595.         final boolean http_stato = connRest.getAutenticazioneHttp() != null;
  596.         final boolean proxy_enabled = connRest.getProxy() != null;
  597.         final boolean tempiRisposta_enabled = connRest.getTempiRisposta() != null;
  598.         
  599.         String httpskeystore = null;
  600.         if ( httpsClient != null ) {
  601.             if ( httpsClient.getKeystorePath() != null || httpsClient.getKeystoreTipo() != null ) {
  602.                 httpskeystore = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI;  
  603.             }
  604.             else
  605.                 httpskeystore = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_DEFAULT;
  606.         }
  607.         

  609.         final BinaryParameter xamlPolicy = new BinaryParameter();
  610.         
  611.         String erogazioneAutenticazione = null;
  612.         boolean erogazioneAutenticazioneOpzionale = true;
  613.         TipoAutenticazionePrincipal erogazioneAutenticazionePrincipal = null;
  614.         List<String> erogazioneAutenticazioneParametroList = null;
  615.         String erogazioneAutorizzazione = null;
  616.         boolean erogazioneAutorizzazioneAutenticati = false;
  617.         boolean erogazioneAutorizzazioneRuoli = false;
  618.         String erogazioneAutorizzazioneRuoliTipologia = null;
  619.         String erogazioneAutorizzazioneRuoliMatch = null;

  621.         String fruizioneAutenticazione = null;
  622.         boolean fruizioneAutenticazioneOpzionale = true;
  623.         TipoAutenticazionePrincipal fruizioneAutenticazionePrincipal = null;
  624.         List<String> fruizioneAutenticazioneParametroList = null;
  625.         String fruizioneAutorizzazione = null;
  626.         boolean fruizioneAutorizzazioneAutenticati = false;
  627.         boolean fruizioneAutorizzazioneRuoli = false;
  628.         String fruizioneAutorizzazioneRuoliTipologia = null;
  629.         String fruizioneAutorizzazioneRuoliMatch = null;
  630.         
  631.         boolean gestioneCanaliEnabled = env.gestioneCanali;
  632.         String canale = null;       
  633.         
  634.         if ( isErogazione ) {
  635.             
  636.             ServletUtils.setObjectIntoSession(env.requestWrapper, env.requestWrapper.getSession(),
  637.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE,
  638.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  639.             
  640.             final IDServizio idServizio = asps.getOldIDServizioForUpdate();
  641.             final IDPortaApplicativa idPA = env.paCore.getIDPortaApplicativaAssociataDefault(idServizio);
  642.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPA);
  643.                         
  644.             erogazioneAutenticazione = pa.getAutenticazione();
  645.             erogazioneAutenticazioneOpzionale = Helper.statoFunzionalitaConfToBool(pa.getAutenticazioneOpzionale());
  646.             erogazioneAutenticazionePrincipal = env.paCore.getTipoAutenticazionePrincipal(pa.getProprietaAutenticazioneList());
  647.             erogazioneAutenticazioneParametroList = env.paCore.getParametroAutenticazione(erogazioneAutenticazione, pa.getProprietaAutenticazioneList());
  648.             
  649.             erogazioneAutorizzazione = pa.getAutorizzazione();
  650.             erogazioneAutorizzazioneAutenticati = TipoAutorizzazione.isAuthenticationRequired(pa.getAutorizzazione());
  651.             erogazioneAutorizzazioneRuoli = TipoAutorizzazione.isRolesRequired(pa.getAutorizzazione());
  652.             erogazioneAutorizzazioneRuoliTipologia =  AutorizzazioneUtilities.convertToRuoloTipologia(pa.getAutorizzazione()).toString();
  653.             erogazioneAutorizzazioneRuoliMatch = evalnull( () -> pa.getRuoli().getMatch().toString() );
  654.             
  655.             if (pa.getXacmlPolicy() != null) {                          
  656.                 xamlPolicy.setValue(pa.getXacmlPolicy().getBytes());
  657.                 xamlPolicy.setName(CostantiControlStation.PARAMETRO_DOCUMENTO_SICUREZZA_XACML_POLICY);
  658.              }
  659.             
  660.             canale = pa.getCanale();
  661.         } else {
  662.             
  663.             ServletUtils.setObjectIntoSession(env.requestWrapper, env.requestWrapper.getSession(),
  664.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE,
  665.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  666.             
  667.             final IDServizio idServizio = asps.getOldIDServizioForUpdate();
  668.             final IDPortaDelegata idPD = env.pdCore.getIDPortaDelegataAssociataDefault(idServizio, env.idSoggetto.toIDSoggetto());
  669.             final PortaDelegata pd = env.pdCore.getPortaDelegata(idPD);
  670.                     
  671.             fruizioneAutenticazione = pd.getAutenticazione();
  672.             fruizioneAutenticazioneOpzionale = Helper.statoFunzionalitaConfToBool(pd.getAutenticazioneOpzionale());
  673.             fruizioneAutenticazionePrincipal = env.pdCore.getTipoAutenticazionePrincipal(pd.getProprietaAutenticazioneList());
  674.             fruizioneAutenticazioneParametroList = env.pdCore.getParametroAutenticazione(fruizioneAutenticazione, pd.getProprietaAutenticazioneList());
  675.             
  676.             fruizioneAutorizzazione = pd.getAutorizzazione();
  677.             fruizioneAutorizzazioneAutenticati = TipoAutorizzazione.isAuthenticationRequired(pd.getAutorizzazione());
  678.             fruizioneAutorizzazioneRuoli =  TipoAutorizzazione.isRolesRequired(pd.getAutorizzazione());
  679.             fruizioneAutorizzazioneRuoliTipologia =  AutorizzazioneUtilities.convertToRuoloTipologia(pd.getAutorizzazione()).toString();
  680.             fruizioneAutorizzazioneRuoliMatch = evalnull( () -> pd.getRuoli().getMatch().toString() );
  681.             
  682.             if (pd.getXacmlPolicy() != null) {                          
  683.                 xamlPolicy.setValue(pd.getXacmlPolicy().getBytes());
  684.                 xamlPolicy.setName(CostantiControlStation.PARAMETRO_DOCUMENTO_SICUREZZA_XACML_POLICY);
  685.             }
  686.             
  687.             canale = pd.getCanale();
  688.         }
  689.         
  690.         String canaleStato = null;
  691.         if(canale == null) {
  692.             canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  693.         } else {
  694.             canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  695.         }
  696.         
  697.         
  698.         final Properties parametersPOST = null;
  699.         org.openspcoop2.core.registry.Connettore conTmp = null;
  700.         List<ExtendedConnettore> listExtendedConnettore = ServletExtendedConnettoreUtils.getExtendedConnettore(conTmp, ConnettoreServletType.ACCORDO_SERVIZIO_PARTE_SPECIFICA_ADD, env.apsHelper, 
  701.                             parametersPOST, false, endpointtype); // uso endpointtype per capire se è la prima volta che entro
  702.                 
  703.         
  704.         IDServizio oldId = asps.getOldIDServizioForUpdate();
  705.                 
  706.         if (! env.apsHelper.serviziCheckData(                   
  707.                 TipoOperazione.CHANGE,
  708.                 soggettiCompatibili,        
  709.                 accordiList,                
  710.                 oldId.getNome(),        //asps.getNome(),               // oldnome
  711.                 oldId.getTipo(),        //asps.getTipo(),               // oldtipo
  712.                 oldId.getVersione(),    //asps.getVersione(),           // oldversione
  713.                 asps.getNome(),
  714.                 asps.getTipo(),
  715.                 erogatore.getId().toString(),   // idSoggErogatore
  716.                 erogatore.getNome(),
  717.                 erogatore.getTipo(),
  718.                 as.getId().toString(),
  719.                 env.apcCore.toMessageServiceBinding(as.getServiceBinding()),
  720.                 "no",  //servcorr,
  721.                 endpointtype, // endpointtype determinarlo dal connettore,
  722.                 endpoint_url,
  723.                 null,   // nome JMS
  724.                 null,   // tipo JMS,
  725.                 httpConf!=null ? evalnull( httpConf::getUsername ) : null,  
  726.                 httpConf!=null ? evalnull( httpConf::getUsername ) : null, 
  727.                 null,   // initcont JMS,
  728.                 null,   // urlpgk JMS,
  729.                 null,   // provurl JMS 
  730.                 null,   // connfact JMS
  731.                 null,   // sendas JMS, 
  732.                 new BinaryParameter(),      //  wsdlimpler
  733.                 new BinaryParameter(),      //  wsdlimplfru
  734.                 asps.getId().toString(),    
  735.                 asps.getVersioneProtocollo(),   //  Il profilo è la versione protocollo in caso spcoop, è quello del soggetto erogatore.
  736.                 asps.getPortType(),
  737.                 ptArray,
  738.                 accordoPrivato,
  739.                 false,  // this.privato,
  740.                 endpoint_url,   // httpsurl, 
  741.                 evalnull( () ->  httpsConf.getTipologia().toString() ),             // I valori corrispondono con con org.openspcoop2.utils.transport.http.SSLConstants
  742.                 BaseHelper.evalorElse( () -> httpsConf.isHostnameVerifier().booleanValue(), false ),                // this.httpshostverify,
  743.                 (httpsConf!=null ? !httpsConf.isTrustAllServerCerts() : ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS), // httpsTrustVerifyCert
  744.                 httpsServer!=null ? evalnull( httpsServer::getTruststorePath ) : null,              // this.httpspath
  745.                 evalnull( () -> ConnettoreHTTPApiHelper.getTruststoreType(httpsServer) ),       // this.httpstipo,
  746.                 httpsServer!=null ? evalnull( httpsServer::getTruststorePassword ) : null,          // this.httpspwd,
  747.                 httpsServer!=null ? evalnull( httpsServer::getAlgoritmo ) : null,                   // this.httpsalgoritmo
  748.                 httpsstato, //
  749.                 httpskeystore,  
  750.                 "", //  this.httpspwdprivatekeytrust
  751.                 httpsClient!=null ? evalnull( httpsClient::getKeystorePath ) : null,                    // httpspathkey
  752.                 evalnull( () -> ConnettoreHTTPApiHelper.getKeystoreType(httpsClient) ),         // httpstipokey, coincide con ConnettoriCostanti.TIPOLOGIE_KEYSTORE
  753.                 httpsClient!=null ? evalnull( httpsClient::getKeystorePassword ) : null,            // httpspwdkey
  754.                 httpsClient!=null ? evalnull( httpsClient::getKeyPassword ) : null,                 // httpspwdprivatekey
  755.                 httpsClient!=null ? evalnull( httpsClient::getAlgoritmo ) : null,                   // httpsalgoritmokey
  756.                 httpsClient!=null ? evalnull( httpsClient::getKeyAlias ) : null,                    // httpsKeyAlias
  757.                 httpsServer!=null ? evalnull( httpsServer::getTruststoreCrl ) : null,                   // httpsTrustStoreCRLs
  758.                 httpsServer!=null ? evalnull( httpsServer::getTruststoreOcspPolicy) : null,             // httpsTrustStoreOCSPPolicy
  759.                 httpsClient!=null ? evalnull( httpsClient::getKeystoreByokPolicy) : null,               // httpsKeyStoreBYOKPolicy
  760.                 null,                               // tipoconn Da debug = null.    
  761.                 as.getVersione().toString(),        // Versione aspc
  762.                 false,                              // validazioneDocumenti Da debug = false
  763.                 null,                               // Da Codice console
  764.                 ServletUtils.boolToCheckBoxStatus(http_stato),  // "yes" se utilizziamo http.
  765.                 ServletUtils.boolToCheckBoxStatus(proxy_enabled),           
  766.                 proxy!=null ? evalnull( proxy::getHostname ) : null,
  767.                 evalnull( () -> proxy.getPorta().toString() ),
  768.                 proxy!=null ? evalnull( proxy::getUsername ) : null,
  769.                 proxy!=null ? evalnull( proxy::getPassword ) : null,                
  770.                 ServletUtils.boolToCheckBoxStatus(tempiRisposta_enabled), 
  771.                 evalnull( () -> timeoutConf.getConnectionTimeout().toString()),     // this.tempiRisposta_connectionTimeout, 
  772.                 evalnull( () -> timeoutConf.getConnectionReadTimeout().toString()),  // this.tempiRisposta_readTimeout, 
  773.                 evalnull( () -> timeoutConf.getTempoMedioRisposta().toString()),        // this.tempiRisposta_tempoMedioRisposta,
  774.                 ServletUtils.boolToCheckBoxStatus(false),   // opzioniAvanzate 
  775.                 "",     // transfer_mode, 
  776.                 "",     // transfer_mode_chunk_size, 
  777.                 "",     // redirect_mode, 
  778.                 "",     // redirect_max_hop, 
  779.                 null,   // requestOutputFileName,
  780.                 null,   // requestOutputFileName_permissions,
  781.                 null,   // requestOutputFileNameHeaders, 
  782.                 null,   // requestOutputFileNameHeaders_permissions, 
  783.                 null,   // requestOutputParentDirCreateIfNotExists, 
  784.                 null,   // requestOutputOverwriteIfExists,
  785.                 null,   // responseInputMode,
  786.                 null,   // responseInputFileName,
  787.                 null,   // responseInputFileNameHeaders,
  788.                 null,   // responseInputDeleteAfterRead,
  789.                 null,   // responseInputWaitTime,
  790.                 null,   // erogazioneSoggetto, Come da codice console.
  791.                 null,   // erogazioneRuolo non viene utilizzato.
  792.                 erogazioneAutenticazione, // erogazioneAutenticazione
  793.                 ServletUtils.boolToCheckBoxStatus(erogazioneAutenticazioneOpzionale),                   // erogazioneAutenticazioneOpzionale
  794.                 erogazioneAutenticazionePrincipal, // erogazioneAutenticazionePrincipal
  795.                 erogazioneAutenticazioneParametroList, // erogazioneAutenticazioneParametroList
  796.                 AutorizzazioneUtilities.convertToStato(erogazioneAutorizzazione), // erogazioneAutorizzazione                                                           // erogazioneAutorizzazione QUESTO E' lo STATO dell'autorizzazione
  797.                 ServletUtils.boolToCheckBoxStatus( erogazioneAutorizzazioneAutenticati ),           // erogazioneAutorizzazioneAutenticati, 
  798.                 ServletUtils.boolToCheckBoxStatus( erogazioneAutorizzazioneRuoli ),             // erogazioneAutorizzazioneRuoli, 
  799.                 erogazioneAutorizzazioneRuoliTipologia,             // erogazioneAutorizzazioneRuoliTipologia,
  800.                 erogazioneAutorizzazioneRuoliMatch,     // erogazioneAutorizzazioneRuoliMatch,  AllAnyEnum == RuoloTipoMatch
  801.                 env.isSupportatoAutenticazioneSoggetti, 
  802.                 isErogazione,                                                   // generaPACheckSoggetto (Un'erogazione genera una porta applicativa)
  803.                 listExtendedConnettore,
  804.                 null,                                                                   // fruizioneServizioApplicativo
  805.                 null,                                                                   // Ruolo fruizione, non viene utilizzato.
  806.                 fruizioneAutenticazione, // fruizioneAutenticazione 
  807.                 ServletUtils.boolToCheckBoxStatus(fruizioneAutenticazioneOpzionale), // fruizioneAutenticazioneOpzionale
  808.                 fruizioneAutenticazionePrincipal, // fruizioneAutenticazionePrincipal
  809.                 fruizioneAutenticazioneParametroList, // fruizioneAutenticazioneParametroList
  810.                 AutorizzazioneUtilities.convertToStato(fruizioneAutorizzazione),        // fruizioneAutorizzazione  
  811.                 ServletUtils.boolToCheckBoxStatus( fruizioneAutorizzazioneAutenticati ),                // fruizioneAutorizzazioneAutenticati, 
  812.                 ServletUtils.boolToCheckBoxStatus( fruizioneAutorizzazioneRuoli ),                  // fruizioneAutorizzazioneRuoli,
  813.                 fruizioneAutorizzazioneRuoliTipologia,      // fruizioneAutorizzazioneRuoliTipologia,
  814.                 fruizioneAutorizzazioneRuoliMatch,      // fruizioneAutorizzazioneRuoliMatch,
  815.                 env.tipo_protocollo, 
  816.                 xamlPolicy,                                                                 //allegatoXacmlPolicy,
  817.                 "",
  818.                 null,       // tipoFruitore 
  819.                 null,   // nomeFruitore
  820.                 autenticazioneToken, 
  821.                 tokenPolicy,
  822.                 
  823.                 apiKey ? org.openspcoop2.web.lib.mvc.Costanti.CHECK_BOX_ENABLED : org.openspcoop2.web.lib.mvc.Costanti.CHECK_BOX_DISABLED, // autenticazioneApiKey
  824.                 apiKey && 
  825.                         env.erogazioniHelper.isAutenticazioneApiKeyUseOAS3Names(
  826.                                 httpApiKey!=null ? evalnull(httpApiKey::getApiKeyHeader) : null, 
  827.                                 httpApiKey!=null ? evalnull(httpApiKey::getAppIdHeader) : null
  828.                 ), // useOAS3Names
  829.                 apiKey && 
  830.                     env.erogazioniHelper.isAutenticazioneApiKeyUseAppId(
  831.                             httpApiKey!=null ? evalnull(httpApiKey::getAppId) : null
  832.                 ), // useAppId
  833.                 httpApiKey!=null ? evalnull( httpApiKey::getApiKeyHeader ) : null, // apiKeyHeader
  834.                 httpApiKey!=null ? evalnull( httpApiKey::getApiKey ) : null, // apiKeyValue
  835.                 httpApiKey!=null ? evalnull( httpApiKey::getAppIdHeader ) : null, // appIdHeader
  836.                 httpApiKey!=null ? evalnull( httpApiKey::getAppId ) : null, // appIdValue       
  837.                 
  838.                 false, // erogazioneServizioApplicativoServerEnabled, 
  839.                 null, // rogazioneServizioApplicativoServer,
  840.                 canaleStato, canale, gestioneCanaliEnabled
  841.             )) {
  842.             throw FaultCode.RICHIESTA_NON_VALIDA.toException( StringEscapeUtils.unescapeHtml( env.pd.getMessage()) );
  843.         }
  844.         
  845.         
  846.     }
  847.     
  848.     public static final List<IDSoggettoDB> getSoggettiCompatibiliAutorizzazione( CredenzialeTipo tipoAutenticazione, Boolean appId, IdSoggetto erogatore, ErogazioniEnv env ) throws DriverRegistroServiziException, DriverConfigurazioneException {
  849.         
  850.         PddTipologia pddTipologiaSoggettoAutenticati = null;
  851.         boolean gestioneErogatoriSoggettiAutenticatiEscludiSoggettoErogatore = false;
  852.         
  853.         
  854.         if(env.apsCore.isMultitenant() && env.apsCore.getMultitenantSoggettiErogazioni()!=null) {
  855.             switch (env.apsCore.getMultitenantSoggettiErogazioni()) {
  856.                 case SOLO_SOGGETTI_ESTERNI:
  857.                     pddTipologiaSoggettoAutenticati = PddTipologia.ESTERNO;
  858.                     break;
  859.                 case ESCLUDI_SOGGETTO_EROGATORE:
  860.                     gestioneErogatoriSoggettiAutenticatiEscludiSoggettoErogatore = true;
  861.                     break;
  862.                 case TUTTI:
  863.                     break;
  864.                 }
  865.         }
  866.         
  867.         List<String> tipiSoggettiGestitiProtocollo = env.soggettiCore.getTipiSoggettiGestitiProtocollo(env.tipo_protocollo);
  868.         
  869.         // calcolo soggetti compatibili con tipi protocollo supportati dalla pa e credenziali indicate
  870.         List<IDSoggettoDB> list = env.soggettiCore.getSoggettiFromTipoAutenticazione(tipiSoggettiGestitiProtocollo, null, tipoAutenticazione, appId, pddTipologiaSoggettoAutenticati);
  871.         
  872.         if( !list.isEmpty() && gestioneErogatoriSoggettiAutenticatiEscludiSoggettoErogatore ) {
  873.             for (int i = 0; i < list.size(); i++) {
  874.                 IDSoggettoDB soggettoCheck = list.get(i);
  875.                 if(soggettoCheck.getTipo().equals(erogatore.getTipo()) && soggettoCheck.getNome().equals(erogatore.getNome())) {
  876.                     list.remove(i);
  877.                     break;
  878.                 }
  879.             }
  880.         }
  881.         
  882.         return list;
  883.     }

  885.     public static org.openspcoop2.utils.BooleanNullable getAutenticazioneOpzionale(Object authn) {
  886.         if(authn!=null) {
  887.             if(authn instanceof APIImplAutenticazioneBasic) {
  888.                 return new org.openspcoop2.utils.BooleanNullable(((APIImplAutenticazioneBasic)authn).isOpzionale());
  889.             }
  890.             else if(authn instanceof APIImplAutenticazioneHttps) {
  891.                 return new org.openspcoop2.utils.BooleanNullable(((APIImplAutenticazioneHttps)authn).isOpzionale());
  892.             }
  893.             else if(authn instanceof APIImplAutenticazionePrincipal) {
  894.                 return new org.openspcoop2.utils.BooleanNullable(((APIImplAutenticazionePrincipal)authn).isOpzionale());
  895.             }
  896.             else if(authn instanceof APIImplAutenticazioneApiKey) {
  897.                 return new org.openspcoop2.utils.BooleanNullable(((APIImplAutenticazioneApiKey)authn).isOpzionale());
  898.             }
  899.             else if(authn instanceof APIImplAutenticazioneCustom) {
  900.                 return new org.openspcoop2.utils.BooleanNullable(((APIImplAutenticazioneCustom)authn).isOpzionale());
  901.             }
  902.         }
  903.         return org.openspcoop2.utils.BooleanNullable.NULL();
  904.     }
  905.     
  906.     public static TipoAutenticazionePrincipal getTipoAutenticazionePrincipal(Object authn){
  907.         if(authn instanceof APIImplAutenticazionePrincipal) {
  908.             
  909.             APIImplAutenticazionePrincipal authPrincipal = (APIImplAutenticazionePrincipal) authn;
  910.             TipoAutenticazioneEnum tipo = authPrincipal.getTipo();
  911.             
  912.             if(TipoAutenticazioneEnum.PRINCIPAL.equals(tipo)) {
  913.                 try {
  914.                     return Enums.tipoAutenticazionePrincipalFromRest.get(authPrincipal.getTipoPrincipal());
  915.                 } catch (Exception e) {
  916.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("La configurazione dell'autenticazione principal non è correttamente definita: " + e.getMessage() );
  917.                 }
  918.             }
  919.         }
  920.         return null;
  921.     }

  923.     public static List<String> getAutenticazioneParametroList(ErogazioniEnv env,TipoAutenticazioneEnum tipo, Object authn) {
  924.         if(TipoAutenticazioneEnum.HTTP_BASIC.equals(tipo)) {
  925.             
  926.             APIImplAutenticazioneBasic authnBasic = null;
  927.             if(authn!=null) {
  928.                 if(authn instanceof APIImplAutenticazioneBasic) {
  929.                     authnBasic = (APIImplAutenticazioneBasic) authn;
  930.                 }
  931.                 else {
  932.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("La configurazione dell'autenticazione '"+tipo+"' non è correttamente definita (trovata configurazione '"+authn.getClass().getName()+"')"  );
  933.                 }
  934.             }
  935.             
  936.             if(authnBasic!=null) {
  937.                 
  938.                 List<Proprieta> listConfig = new ArrayList<>();
  939.                 if(authnBasic.isForward()!=null) {
  940.                     Proprieta propertyAutenticazione = new Proprieta();
  941.                     propertyAutenticazione.setNome(ParametriAutenticazioneBasic.CLEAN_HEADER_AUTHORIZATION);
  942.                     if(authnBasic.isForward().booleanValue()) { 
  943.                         propertyAutenticazione.setValore(ParametriAutenticazioneBasic.CLEAN_HEADER_AUTHORIZATION_FALSE);
  944.                     }
  945.                     else {
  946.                         propertyAutenticazione.setValore(ParametriAutenticazioneBasic.CLEAN_HEADER_AUTHORIZATION_TRUE);
  947.                     }
  948.                     listConfig.add(propertyAutenticazione);
  949.                 }
  950.                 
  951.                 if(!listConfig.isEmpty()) {
  952.                     return env.stationCore.getParametroAutenticazione(Enums.tipoAutenticazioneFromRest.get(tipo).toString(), listConfig);
  953.                 }
  954.             }
  955.             
  956.         }
  957.         else if(TipoAutenticazioneEnum.PRINCIPAL.equals(tipo)) {
  958.             
  959.             APIImplAutenticazionePrincipal authnPrincipal = null;
  960.             if(authn!=null) {
  961.                 if(authn instanceof APIImplAutenticazionePrincipal) {
  962.                     authnPrincipal = (APIImplAutenticazionePrincipal) authn;
  963.                 }
  964.                 else {
  965.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("La configurazione dell'autenticazione '"+tipo+"' non è correttamente definita (trovata configurazione '"+authn.getClass().getName()+"')"  );
  966.                 }
  967.             }
  968.             
  969.             if(authnPrincipal!=null) {  
  970.                 
  971.                 TipoAutenticazionePrincipal autenticazionePrincipal = Enums.tipoAutenticazionePrincipalFromRest.get(authnPrincipal.getTipoPrincipal());
  972.                 Proprieta propTipoAuthn = new Proprieta();
  973.                 propTipoAuthn.setNome(ParametriAutenticazionePrincipal.TIPO_AUTENTICAZIONE);
  974.                 propTipoAuthn.setValore(autenticazionePrincipal.getValue());
  975.                 
  976.                 List<Proprieta> listConfig = new ArrayList<>();
  977.                 listConfig.add(propTipoAuthn);
  978.                 switch (autenticazionePrincipal) {
  979.                 case CONTAINER:
  980.                 case INDIRIZZO_IP:
  981.                 case INDIRIZZO_IP_X_FORWARDED_FOR:
  982.                     break;
  983.                 case HEADER:
  984.                     if(authnPrincipal.getNome()==null) {
  985.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è stato indicato il nome di un header http per l'autenticazione principal '"+authnPrincipal.getTipoPrincipal()+"' indicata");
  986.                     }
  987.                     Proprieta propertyAutenticazione = new Proprieta();
  988.                     propertyAutenticazione.setNome(ParametriAutenticazionePrincipal.NOME);
  989.                     propertyAutenticazione.setValore(authnPrincipal.getNome());
  990.                     listConfig.add(propertyAutenticazione);
  991.                     break;
  992.                 case FORM:
  993.                     if(authnPrincipal.getNome()==null) {
  994.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è stato indicato il nome di un parametro della url per l'autenticazione principal '"+authnPrincipal.getTipoPrincipal()+"' indicata");
  995.                     }
  996.                     propertyAutenticazione = new Proprieta();
  997.                     propertyAutenticazione.setNome(ParametriAutenticazionePrincipal.NOME);
  998.                     propertyAutenticazione.setValore(authnPrincipal.getNome());
  999.                     listConfig.add(propertyAutenticazione);
  1000.                     break;
  1001.                 case URL:
  1002.                     if(authnPrincipal.getPattern()==null) {
  1003.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è stata fornita una espressione regolare per l'autenticazione principal '"+authnPrincipal.getTipoPrincipal()+"' indicata");
  1004.                     }
  1005.                     propertyAutenticazione = new Proprieta();
  1006.                     propertyAutenticazione.setNome(ParametriAutenticazionePrincipal.PATTERN);
  1007.                     propertyAutenticazione.setValore(authnPrincipal.getPattern());
  1008.                     listConfig.add(propertyAutenticazione);
  1009.                     break;
  1010.                 case TOKEN:
  1011.                     if(authnPrincipal.getToken()==null) {
  1012.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è stato indicato il token claim, da cui estrarre il principal, per l'autenticazione '"+authnPrincipal.getTipoPrincipal()+"' indicata");
  1013.                     }
  1014.                     if(TipoAutenticazionePrincipalToken.CUSTOM.equals(authnPrincipal.getToken())) {
  1015.                         if(authnPrincipal.getNome()==null) {
  1016.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è stato indicato il nome del token claim, da cui estrarre il principal, per l'autenticazione '"+authnPrincipal.getTipoPrincipal()+"' indicata");
  1017.                         }
  1018.                     }
  1019.                     propertyAutenticazione = new Proprieta();
  1020.                     propertyAutenticazione.setNome(ParametriAutenticazionePrincipal.TOKEN_CLAIM);
  1021.                     switch (authnPrincipal.getToken()) {
  1022.                     case SUBJECT:
  1023.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.TOKEN_CLAIM_SUBJECT); 
  1024.                         break;
  1025.                     case CLIENTID:
  1026.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CLIENT_ID);   
  1027.                         break;
  1028.                     case USERNAME:
  1029.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.TOKEN_CLAIM_USERNAME);    
  1030.                         break;
  1031.                     case EMAIL:
  1032.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.TOKEN_CLAIM_EMAIL);   
  1033.                         break;
  1034.                     case CUSTOM:
  1035.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CUSTOM);  
  1036.                         break;
  1037.                     }
  1038.                     listConfig.add(propertyAutenticazione);
  1039.                     
  1040.                     if(TipoAutenticazionePrincipalToken.CUSTOM.equals(authnPrincipal.getToken())) {
  1041.                         propertyAutenticazione = new Proprieta();
  1042.                         propertyAutenticazione.setNome(ParametriAutenticazionePrincipal.NOME);
  1043.                         propertyAutenticazione.setValore(authnPrincipal.getNome());
  1044.                         listConfig.add(propertyAutenticazione);
  1045.                     }
  1046.                     
  1047.                     break;
  1048.                 }
  1049.                 
  1050.                 if(authnPrincipal.isForward()!=null) {
  1051.                     
  1052.                     Proprieta propertyAutenticazione = new Proprieta();
  1053.                     propertyAutenticazione.setNome(ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL);
  1054.                     if(authnPrincipal.isForward()) {
  1055.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL_FALSE);
  1056.                     }
  1057.                     else {
  1058.                         propertyAutenticazione.setValore(ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL_TRUE);
  1059.                     }
  1060.                     listConfig.add(propertyAutenticazione);
  1061.                 }
  1062.                 
  1063.                 if(!listConfig.isEmpty()) {
  1064.                     return env.stationCore.getParametroAutenticazione(tipo.toString(), listConfig);
  1065.                 }
  1066.             }
  1067.             else {
  1068.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Autenticazione principal non correttamente formata");
  1069.             }
  1070.         }
  1071.         else if(TipoAutenticazioneEnum.API_KEY.equals(tipo)) {
  1072.             
  1073.             APIImplAutenticazioneApiKey authnApiKey = null;
  1074.             if(authn!=null) {
  1075.                 if(authn instanceof APIImplAutenticazioneApiKey) {
  1076.                     authnApiKey = (APIImplAutenticazioneApiKey) authn;
  1077.                 }
  1078.                 else {
  1079.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("La configurazione dell'autenticazione '"+tipo+"' non è correttamente definita (trovata configurazione '"+authn.getClass().getName()+"')"  );
  1080.                 }
  1081.             }
  1082.             
  1083.             if(authn!=null) {
  1084.                 
  1085.                 List<Proprieta> listConfig = new ArrayList<>();
  1086.                 
  1087.                 // posizione 0: appId
  1088.                 _addProprieta(ParametriAutenticazioneApiKey.APP_ID, 
  1089.                         authnApiKey.isAppId()!=null && authnApiKey.isAppId() ? ParametriAutenticazioneApiKey.APP_ID_TRUE : ParametriAutenticazioneApiKey.APP_ID_FALSE, 
  1090.                                 listConfig);

  1092.                 // posizione 1: queryParameter
  1093.                 if(authnApiKey.getPosizione()!=null && authnApiKey.getPosizione().isQueryParameter()!=null) {
  1094.                     _addProprieta(ParametriAutenticazioneApiKey.QUERY_PARAMETER, 
  1095.                             authnApiKey.getPosizione().isQueryParameter() ? 
  1096.                                     ParametriAutenticazioneApiKey.QUERY_PARAMETER_TRUE : ParametriAutenticazioneApiKey.QUERY_PARAMETER_FALSE, 
  1097.                                     listConfig);
  1098.                 }
  1099.                 else {
  1100.                     APIImplAutenticazioneApiKeyPosizione defaultValues = new APIImplAutenticazioneApiKeyPosizione(); // uso i default
  1101.                     _addProprieta(ParametriAutenticazioneApiKey.QUERY_PARAMETER, 
  1102.                             defaultValues.isQueryParameter() ? 
  1103.                                     ParametriAutenticazioneApiKey.QUERY_PARAMETER_TRUE : ParametriAutenticazioneApiKey.QUERY_PARAMETER_FALSE, 
  1104.                                     listConfig);
  1105.                 }
  1106.                 
  1107.                 // posizione 2: header
  1108.                 if(authnApiKey.getPosizione()!=null && authnApiKey.getPosizione().isHeader()!=null) {
  1109.                     _addProprieta(ParametriAutenticazioneApiKey.HEADER, 
  1110.                             authnApiKey.getPosizione().isHeader() ? 
  1111.                                     ParametriAutenticazioneApiKey.HEADER_TRUE : ParametriAutenticazioneApiKey.HEADER_FALSE, 
  1112.                                     listConfig);                
  1113.                 }
  1114.                 else {
  1115.                     APIImplAutenticazioneApiKeyPosizione defaultValues = new APIImplAutenticazioneApiKeyPosizione(); // uso i default
  1116.                     _addProprieta(ParametriAutenticazioneApiKey.HEADER, 
  1117.                             defaultValues.isHeader() ? 
  1118.                                     ParametriAutenticazioneApiKey.HEADER_TRUE : ParametriAutenticazioneApiKey.HEADER_FALSE, 
  1119.                                     listConfig);
  1120.                 }
  1121.                 
  1122.                 // posizione 3: cookie
  1123.                 if(authnApiKey.getPosizione()!=null && authnApiKey.getPosizione().isCookie()!=null) {
  1124.                     _addProprieta(ParametriAutenticazioneApiKey.COOKIE, 
  1125.                             authnApiKey.getPosizione().isCookie() ? 
  1126.                                     ParametriAutenticazioneApiKey.COOKIE_TRUE : ParametriAutenticazioneApiKey.COOKIE_FALSE, 
  1127.                                     listConfig);    
  1128.                 }
  1129.                 else {
  1130.                     APIImplAutenticazioneApiKeyPosizione defaultValues = new APIImplAutenticazioneApiKeyPosizione(); // uso i default
  1131.                     _addProprieta(ParametriAutenticazioneApiKey.COOKIE, 
  1132.                             defaultValues.isCookie() ? 
  1133.                                     ParametriAutenticazioneApiKey.COOKIE_TRUE : ParametriAutenticazioneApiKey.COOKIE_FALSE, 
  1134.                                     listConfig);
  1135.                 }
  1136.                 
  1137.                 // posizione 4: useOAS3Names
  1138.                 boolean apiKeyNamesCustom = false;
  1139.                 boolean appIdNamesCustom = false;
  1140.                 if(authnApiKey.getApiKeyNomi()!=null) {
  1141.                     if(StringUtils.isNotEmpty(authnApiKey.getApiKeyNomi().getQueryParameter()) ||
  1142.                             StringUtils.isNotEmpty(authnApiKey.getApiKeyNomi().getHeader()) ||
  1143.                             StringUtils.isNotEmpty(authnApiKey.getApiKeyNomi().getCookie())) {
  1144.                         apiKeyNamesCustom = true;
  1145.                     }
  1146.                 }
  1147.                 if(authnApiKey.getAppIdNomi()!=null) {
  1148.                     if(StringUtils.isNotEmpty(authnApiKey.getAppIdNomi().getQueryParameter()) ||
  1149.                             StringUtils.isNotEmpty(authnApiKey.getAppIdNomi().getHeader()) ||
  1150.                             StringUtils.isNotEmpty(authnApiKey.getAppIdNomi().getCookie())) {
  1151.                         appIdNamesCustom = true;
  1152.                     }
  1153.                 }
  1154.                 _addProprieta(ParametriAutenticazioneApiKey.USE_OAS3_NAMES, 
  1155.                         apiKeyNamesCustom || appIdNamesCustom  ? ParametriAutenticazioneApiKey.USE_OAS3_NAMES_FALSE : ParametriAutenticazioneApiKey.USE_OAS3_NAMES_TRUE, 
  1156.                                 listConfig);
  1157.                 
  1158.                 // posizione 5: cleanApiKey
  1159.                 _addProprieta(ParametriAutenticazioneApiKey.CLEAN_API_KEY, 
  1160.                         authnApiKey.isApiKeyForward()!=null && authnApiKey.isApiKeyForward() ? ParametriAutenticazioneApiKey.CLEAN_API_KEY_FALSE : ParametriAutenticazioneApiKey.CLEAN_API_KEY_TRUE, 
  1161.                                 listConfig);    
  1162.                 
  1163.                 // posizione 6: cleanAppId
  1164.                 _addProprieta(ParametriAutenticazioneApiKey.CLEAN_APP_ID, 
  1165.                         authnApiKey.isAppIdForward()!=null && authnApiKey.isAppIdForward() ? ParametriAutenticazioneApiKey.CLEAN_APP_ID_FALSE : ParametriAutenticazioneApiKey.CLEAN_APP_ID_TRUE, 
  1166.                                 listConfig);
  1167.                 
  1168.                 // posizione 7: queryParameterApiKey
  1169.                 _addProprieta(ParametriAutenticazioneApiKey.NOME_QUERY_PARAMETER_API_KEY, 
  1170.                         apiKeyNamesCustom && StringUtils.isNotEmpty(authnApiKey.getApiKeyNomi().getQueryParameter()) ? authnApiKey.getApiKeyNomi().getQueryParameter() : ParametriAutenticazioneApiKey.DEFAULT_QUERY_PARAMETER_API_KEY, 
  1171.                                 listConfig);
  1172.                 
  1173.                 // posizione 8: headerApiKey
  1174.                 _addProprieta(ParametriAutenticazioneApiKey.NOME_HEADER_API_KEY, 
  1175.                         apiKeyNamesCustom && StringUtils.isNotEmpty(authnApiKey.getApiKeyNomi().getHeader()) ? authnApiKey.getApiKeyNomi().getHeader() : ParametriAutenticazioneApiKey.DEFAULT_HEADER_API_KEY, 
  1176.                                 listConfig);
  1177.                 
  1178.                 // posizione 9: cookieApiKey
  1179.                 _addProprieta(ParametriAutenticazioneApiKey.NOME_COOKIE_API_KEY, 
  1180.                         apiKeyNamesCustom && StringUtils.isNotEmpty(authnApiKey.getApiKeyNomi().getCookie()) ? authnApiKey.getApiKeyNomi().getCookie() : ParametriAutenticazioneApiKey.DEFAULT_COOKIE_API_KEY, 
  1181.                                 listConfig);
  1182.                 
  1183.                 // posizione 10: queryParameterAppId
  1184.                 _addProprieta(ParametriAutenticazioneApiKey.NOME_QUERY_PARAMETER_APP_ID, 
  1185.                         appIdNamesCustom && StringUtils.isNotEmpty(authnApiKey.getAppIdNomi().getQueryParameter()) ? authnApiKey.getAppIdNomi().getQueryParameter() : ParametriAutenticazioneApiKey.DEFAULT_QUERY_PARAMETER_APP_ID, 
  1186.                                 listConfig);

  1188.                 // posizione 11: headerAppId
  1189.                 _addProprieta(ParametriAutenticazioneApiKey.NOME_HEADER_APP_ID, 
  1190.                         appIdNamesCustom && StringUtils.isNotEmpty(authnApiKey.getAppIdNomi().getHeader()) ? authnApiKey.getAppIdNomi().getHeader() : ParametriAutenticazioneApiKey.DEFAULT_HEADER_APP_ID, 
  1191.                                 listConfig);

  1193.                 // posizione 12: cookieAppId
  1194.                 _addProprieta(ParametriAutenticazioneApiKey.NOME_COOKIE_APP_ID, 
  1195.                         appIdNamesCustom && StringUtils.isNotEmpty(authnApiKey.getAppIdNomi().getCookie()) ? authnApiKey.getAppIdNomi().getCookie() : ParametriAutenticazioneApiKey.DEFAULT_COOKIE_APP_ID, 
  1196.                                 listConfig);

  1198.                 if(!listConfig.isEmpty()) {
  1199.                     return env.stationCore.getParametroAutenticazione(Enums.tipoAutenticazioneFromRest.get(tipo).toString(), listConfig);
  1200.                 }
  1201.             }
  1202.             
  1203.         }
  1204.         return null;
  1205.     }

  1207.     private static final void _addProprieta(String nome, String valore, List<Proprieta> listConfig) {
  1208.         Proprieta propertyAutenticazione = new Proprieta();
  1209.         propertyAutenticazione.setNome(nome);
  1210.         propertyAutenticazione.setValore(valore);
  1211.         listConfig.add(propertyAutenticazione);
  1212.     }
  1213.     
  1214.     public static final void serviziCheckData(  
  1215.             TipoOperazione tipoOp,
  1216.             ErogazioniEnv env,
  1217.             AccordoServizioParteComuneSintetico as,
  1218.             AccordoServizioParteSpecifica asps,
  1219.             Optional<IdSoggetto> fruitore,
  1220.             APIImpl impl

  1222.             ) throws Exception {
  1223.         
  1224.         boolean generaPortaApplicativa = !fruitore.isPresent();
  1225.         IdSoggetto erogatore = new IdSoggetto( new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()));
  1226.         erogatore.setId(asps.getIdSoggetto());
  1227.         
  1228.          if (impl == null) { 
  1229.              impl = new APIImpl();
  1230.              impl.setConnettore(new BaseConnettoreHttp());
  1231.          }
  1232.         
  1233.          boolean accordoPrivato = as.getPrivato()!=null && as.getPrivato();     
  1234.          
  1235.          List<PortTypeSintetico> ptList = AccordiServizioParteSpecificaUtilities.getListaPortTypes(as, env.apsHelper);
  1236.          
  1237.          String[] ptArray =  ptList.stream()
  1238.                 .map( p -> p.getNome() )
  1239.                 .toArray(String[]::new);
  1240.         
  1241.          // Determino i soggetti compatibili
  1242.         ConsoleSearch searchSoggetti = new ConsoleSearch(true);
  1243.         searchSoggetti.addFilter(Liste.SOGGETTI, Filtri.FILTRO_PROTOCOLLO, env.tipo_protocollo);
  1244.         boolean fruizioniEscludiSoggettoFruitore = false;
  1245.         
  1246.         // In caso di Fruizione i soggetti erogatori compatibili sono determinati dalla configurazione di GovWay (tutti, escluso erogatore, esterni)
  1247.         if ( fruitore.isPresent() ) {
  1248.             ConfigurazioneCore confCore = new ConfigurazioneCore(env.stationCore);
  1249.             PortaDelegataSoggettiErogatori confFruizioneErogatori = confCore.getConfigurazioneGenerale().getMultitenant().getFruizioneSceltaSoggettiErogatori();
  1250.             
  1251.             if (confFruizioneErogatori == PortaDelegataSoggettiErogatori.SOGGETTI_ESTERNI) {
  1252.                 searchSoggetti.addFilter(Liste.SOGGETTI, Filtri.FILTRO_DOMINIO, SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE);
  1253.             }
  1254.             else if ( confFruizioneErogatori == PortaDelegataSoggettiErogatori.ESCLUDI_SOGGETTO_FRUITORE ) {
  1255.                 fruizioniEscludiSoggettoFruitore = true;
  1256.             }
  1257.             
  1258.         } // In caso di erogazione invece possiamo solo assegnare soggetti appartenenti a una porta di tipo operativo. 
  1259.         else {
  1260.             searchSoggetti.addFilter(Liste.SOGGETTI, Filtri.FILTRO_DOMINIO, SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE);
  1261.         }
  1262.         
  1263.         List<Soggetto> listSoggetti = env.soggettiCore.soggettiRegistroList(null, searchSoggetti);
  1264.         
  1265.         final boolean escludiFruitore = fruizioniEscludiSoggettoFruitore;
  1266.         String[] soggettiCompatibili = listSoggetti.stream()
  1267.                 .filter( s -> generaPortaApplicativa || ( !escludiFruitore || (s.getId().longValue() != fruitore.get().getId().longValue()) ) )
  1268.                 .map( s -> s.getId().toString())
  1269.                 .toArray(String[]::new);
  1270.         
  1271.         if (soggettiCompatibili.length == 0) {
  1272.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non ci sono soggetti compatibili per erogare il servizio");
  1273.         }
  1274.         
  1275.         
  1276.         // Determino la lista Api
  1277.         List<IDAccordoDB> listaIdAPI = AccordiServizioParteSpecificaUtilities.getListaIdAPI(
  1278.                 env.tipo_protocollo,
  1279.                 env.userLogin,
  1280.                 env.apsCore, 
  1281.                 env.apsHelper
  1282.             );
  1283.         
  1284.         String[] accordiList =  listaIdAPI.stream()
  1285.                 .map( a -> a.getId().toString() )
  1286.                 .toArray(String[]::new);
  1287.         
  1288.         final BaseConnettoreHttp conn = impl.getConnettore();
  1289.         final ConnettoreConfigurazioneApiKey httpApiKey = conn.getAutenticazioneApikey();
  1290.         boolean apiKey = (httpApiKey!=null && httpApiKey.getApiKey()!=null && StringUtils.isNotEmpty(httpApiKey.getApiKey()));
  1291.         final ConnettoreConfigurazioneHttps httpsConf    = conn.getAutenticazioneHttps();
  1292.         final ConnettoreConfigurazioneHttpBasic httpConf     = conn.getAutenticazioneHttp();
  1293.         
  1294.         final String endpointtype = httpsConf != null ? TipiConnettore.HTTPS.getNome() : TipiConnettore.HTTP.getNome();
  1295.         

  1297.         final Properties parametersPOST = null;
  1298.         org.openspcoop2.core.registry.Connettore conTmp = null;
  1299.         List<ExtendedConnettore> listExtendedConnettore = 
  1300.                 ServletExtendedConnettoreUtils.getExtendedConnettore(conTmp, ConnettoreServletType.ACCORDO_SERVIZIO_PARTE_SPECIFICA_ADD, env.apsHelper, 
  1301.                             parametersPOST, false, endpointtype); // uso endpointtype per capire se è la prima volta che entro
  1302.     
  1303.         
  1304.         final ConnettoreConfigurazioneHttpsClient httpsClient = httpsConf!=null ? evalnull( httpsConf::getClient ) : null;
  1305.         final ConnettoreConfigurazioneHttpsServer httpsServer = httpsConf!=null ? evalnull( httpsConf::getServer ) : null;
  1306.         final ConnettoreConfigurazioneProxy       proxy       = conn.getProxy();
  1307.         final ConnettoreConfigurazioneTimeout     timeoutConf = conn.getTempiRisposta();
  1308.         final String tokenPolicy = conn.getTokenPolicy(); 
  1309.         final boolean autenticazioneToken = tokenPolicy!=null;

  1311.         
  1312.         final boolean httpsstato = httpsClient != null;
  1313.         final boolean http_stato = conn.getAutenticazioneHttp() != null;
  1314.         final boolean proxy_enabled = conn.getProxy() != null;
  1315.         final boolean tempiRisposta_enabled = conn.getTempiRisposta() != null; 
  1316.         
  1317.         String httpskeystore = null;
  1318.         if ( httpsClient != null ) {
  1319.             if ( httpsClient.getKeystorePath() != null || httpsClient.getKeystoreTipo() != null ) {
  1320.                 httpskeystore = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI;  
  1321.             }
  1322.             else
  1323.                 httpskeystore = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_DEFAULT;
  1324.         }

  1326.         // Autenticazione e autorizzazione sono opzionali nel json.
  1327.         final OneOfAPIImplAutorizzazione authz = impl.getAutorizzazione();
  1328.         final OneOfAPIImplAutenticazione authn = impl.getAutenticazione();
  1329.         
  1330.         // Vincolo rilasciato
  1331.         // Se sono in modalità SPCoop non posso specificare l'autenticazione
  1332.         /**if ( env.profilo == ProfiloEnum.SPCOOP && generaPortaApplicativa && authn != null ) {
  1333.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è possibile specificare l'autenticazione per un servizio spcoop");
  1334.         }*/
  1335.         
  1336.         FonteEnum ruoliFonte = FonteEnum.QUALSIASI;
  1337.         String erogazioneRuolo = null;
  1338.         boolean isRichiedente = false;
  1339.         boolean isRuoli = false;
  1340.         String statoAutorizzazione = null;
  1341.         TipoAutenticazionePrincipal autenticazionePrincipal = null;
  1342.         List<String> autenticazioneParametroList = null;
  1343.         if(authn!=null) {
  1344.             autenticazionePrincipal = getTipoAutenticazionePrincipal(authn); 
  1345.             autenticazioneParametroList = getAutenticazioneParametroList(env, authn.getTipo(), authn);
  1346.         }
  1347.         final BooleanNullable autenticazioneOpzionaleNullable = getAutenticazioneOpzionale(authn); // gestisce authn se null
  1348.         AllAnyEnum ruoliRichiesti = null;
  1349.         
  1350.         if ( generaPortaApplicativa && as.getServiceBinding() == ServiceBinding.SOAP && authz != null && authz.getTipo() != null ) {
  1351.             switch ( authz.getTipo() ) {
  1352.             case ABILITATO:
  1353.                 
  1354.                 if(authz instanceof APIImplAutorizzazioneAbilitataNew) {
  1355.                 
  1356.                     APIImplAutorizzazioneAbilitataNew authzAbilitata = (APIImplAutorizzazioneAbilitataNew) authz;
  1357.                     
  1358.                     if(authzAbilitata.getRuoliFonte()!=null) {
  1359.                         ruoliFonte = authzAbilitata.getRuoliFonte();
  1360.                     }
  1361.                     erogazioneRuolo = authzAbilitata.getRuolo();
  1362.                     isRichiedente = authzAbilitata.isRichiedente();
  1363.                     isRuoli = authzAbilitata.isRuoli();
  1364.                     statoAutorizzazione = AutorizzazioneUtilities.STATO_ABILITATO;
  1365.                     ruoliRichiesti = authzAbilitata.getRuoliRichiesti();
  1366.                 }
  1367.                 else {
  1368.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  1369.                 }
  1370.                 break;
  1371.             case XACML_POLICY:
  1372.                 
  1373.                 if(authz instanceof APIImplAutorizzazioneXACML) {
  1374.                     
  1375.                     APIImplAutorizzazioneXACML authzXacml = (APIImplAutorizzazioneXACML) authz;
  1376.                 
  1377.                     if (authzXacml.getPolicy() == null) {
  1378.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Campo obbligatorio 'policy' non presente nell'autorizzazione indicata");
  1379.                     }
  1380.                     if(authzXacml.getRuoliFonte()!=null) {
  1381.                         ruoliFonte = authzXacml.getRuoliFonte();
  1382.                     }
  1383.                     statoAutorizzazione = AutorizzazioneUtilities.STATO_XACML_POLICY;
  1384.                 }
  1385.                 else {
  1386.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  1387.                 }
  1388.                 break;
  1389.             case DISABILITATO:
  1390.                 statoAutorizzazione = AutorizzazioneUtilities.STATO_DISABILITATO;
  1391.                 break;
  1392.             case CUSTOM:
  1393.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Tipo di autorizzazione '"+authz.getTipo()+"' non utilizzabile");
  1394.             }
  1395.         }
  1396.         
  1397.         if (isRichiedente) {
  1398.             
  1399.             final APIImplAutorizzazioneAbilitataNew configAuthzFinal = (APIImplAutorizzazioneAbilitataNew) authz;
  1400.                         
  1401.             // Se ho abilitata l'autorizzazione puntuale, devo aver anche abilitata l'autenticazione
  1402.             if ( env.isSupportatoAutenticazioneSoggetti && 
  1403.                     (authn == null || authn.getTipo() == TipoAutenticazioneEnum.DISABILITATO)  &&
  1404.                     (!generaPortaApplicativa || !env.isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazione) 
  1405.                     ){
  1406.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ABILITARE_AUTENTICAZIONE_PER_AUTORIZZAZIONE_PUNTUALE);
  1407.             }
  1408.         
  1409.             if ( !StringUtils.isEmpty(configAuthzFinal.getSoggetto()) ) {
  1410.                 
  1411.                 CredenzialeTipo credTipo = evalnull( () -> Enums.credenzialeTipoFromTipoAutenticazione.get(authn.getTipo()) );
  1412.                 Boolean appId = null; // da fare APIKEY
  1413.                 Optional<String> soggettoCompatibile = getSoggettiCompatibiliAutorizzazione(credTipo, appId, env.idSoggetto, env)
  1414.                         .stream()
  1415.                         .map( IDSoggettoDB::getNome )
  1416.                         .filter( s -> s.equals( configAuthzFinal.getSoggetto() ) )
  1417.                         .findAny();
  1418.             
  1419.                 //Se ho scelto un soggetto, questo deve esistere ed essere compatibile con il profilo di autenticazione
  1420.                 if ( !soggettoCompatibile.isPresent() ) {
  1421.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il soggetto " + configAuthzFinal.getSoggetto() + " scelto per l'autorizzazione puntuale non esiste o non è compatibile con la modalità di autenticazione scelta");
  1422.                 }
  1423.             }
  1424.             
  1425.         }
  1426.         
  1427.         if (isRuoli) {
  1428.             
  1429.             final APIImplAutorizzazioneAbilitataNew configAuthzFinal = (APIImplAutorizzazioneAbilitataNew) authz;
  1430.             
  1431.             if (!StringUtils.isEmpty(configAuthzFinal.getRuolo())) {
  1432.                 RuoliCore ruoliCore = new RuoliCore(env.stationCore);
  1433.                 // Il ruolo deve esistere
  1434.                 org.openspcoop2.core.registry.Ruolo regRuolo = null;
  1435.                 try {
  1436.                     regRuolo = ruoliCore.getRuolo(configAuthzFinal.getRuolo());
  1437.                 } catch (DriverConfigurazioneException e) { 
  1438.                     // ignore
  1439.                 }
  1440.                 
  1441.                 if (regRuolo == null) {
  1442.                     throw FaultCode.NOT_FOUND.toException("Non esiste nessun ruolo con nome " + configAuthzFinal.getRuolo());
  1443.                 }
  1444.             }
  1445.         }
  1446.         
  1447.     
  1448.         final BinaryParameter xamlPolicy = new BinaryParameter();
  1449.         if(authz instanceof APIImplAutorizzazioneXACML) {
  1450.             APIImplAutorizzazioneXACML authzXacml = (APIImplAutorizzazioneXACML) authz;
  1451.             xamlPolicy.setValue(authzXacml.getPolicy());
  1452.         }
  1453.         xamlPolicy.setName(CostantiControlStation.PARAMETRO_DOCUMENTO_SICUREZZA_XACML_POLICY);
  1454.         
  1455.         
  1456.         StringBuilder inUsoMessage = new StringBuilder();
  1457.         
  1458.         if ( AccordiServizioParteSpecificaUtilities.alreadyExists(
  1459.                 env.apsCore, 
  1460.                 env.apsHelper, 
  1461.                 erogatore.getId(), 
  1462.                 env.idServizioFactory.getIDServizioFromAccordo(asps),
  1463.                 env.idAccordoFactory.getUriFromAccordo(as),
  1464.                 evalnull( () -> fruitore.get().getTipo() ),
  1465.                 evalnull( () -> fruitore.get().getNome() ),
  1466.                 env.tipo_protocollo,
  1467.                 asps.getVersioneProtocollo(),
  1468.                 asps.getPortType(),
  1469.                 ! generaPortaApplicativa,
  1470.                 generaPortaApplicativa,
  1471.                 inUsoMessage
  1472.             ) ) {
  1473.             throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml( inUsoMessage.toString() ));
  1474.         }

  1476.         /**final String tipoAutorString =   AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString( authz.getTipo(),
  1477.                 isPuntuale,
  1478.                 isRuoli,
  1479.                 false,
  1480.                 ServletUtils.isCheckBoxEnabled(autorizzazioneScope),        
  1481.                 autorizzazione_tokenOptions,                    // Questo è il token claims
  1482.                 tipoRuoloFonte                                  // RuoliFonte: Qualsiasi, Registro, Esterna
  1483.             );*/
  1484.         
  1485.         boolean gestioneCanaliEnabled = env.gestioneCanali;
  1486.         String canale = null;
  1487.         if(gestioneCanaliEnabled) {
  1488.             if(impl instanceof Erogazione) {
  1489.                 canale = ((Erogazione)impl).getCanale();
  1490.             }
  1491.             else if(impl instanceof Fruizione) {
  1492.                 canale = ((Fruizione)impl).getCanale();
  1493.             }
  1494.             if(canale!=null &&
  1495.                 !env.canali.contains(canale)) {
  1496.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il canale fornito '" + canale + "' non è presente nel registro");
  1497.             }
  1498.         }
  1499.         String canaleStato = null;
  1500.         if(canale == null) {
  1501.             canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  1502.         } else {
  1503.             canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  1504.         }
  1505.         
  1506.         if (! env.apsHelper.serviziCheckData(                   
  1507.                 tipoOp,
  1508.                 soggettiCompatibili,        
  1509.                 accordiList,                
  1510.                 asps.getNome(),             // oldnome
  1511.                 asps.getTipo(),             // oldtipo
  1512.                 asps.getVersione(),         // oldversione
  1513.                 asps.getNome(),
  1514.                 asps.getTipo(),
  1515.                 erogatore.getId().toString(),   // idSoggErogatore
  1516.                 erogatore.getNome(),
  1517.                 erogatore.getTipo(),
  1518.                 as.getId().toString(),
  1519.                 env.apcCore.toMessageServiceBinding(as.getServiceBinding()),
  1520.                 "no",  //servcorr,
  1521.                 endpointtype, // endpointtype determinarlo dal connettore,
  1522.                 impl.getConnettore().getEndpoint(),
  1523.                 null,   // nome JMS
  1524.                 null,   // tipo JMS,
  1525.                 httpConf!=null ? evalnull( httpConf::getUsername ) : null,  
  1526.                 httpConf!=null ? evalnull( httpConf::getPassword ) : null, 
  1527.                 null,   // initcont JMS,
  1528.                 null,   // urlpgk JMS,
  1529.                 null,   // provurl JMS 
  1530.                 null,   // connfact JMS
  1531.                 null,   // sendas JMS, 
  1532.                 new BinaryParameter(),      //  wsdlimpler
  1533.                 new BinaryParameter(),      //  wsdlimplfru
  1534.                 BaseHelper.evalorElse( () -> asps.getId().toString(), "0"),     
  1535.                 asps.getVersioneProtocollo(),   //  Il profilo è la versione protocollo in caso spcoop, è quello del soggetto erogatore.
  1536.                 asps.getPortType(),
  1537.                 ptArray,
  1538.                 accordoPrivato,
  1539.                 false,  // this.privato,
  1540.                 conn.getEndpoint(), // httpsurl, 
  1541.                 evalnull( () ->  httpsConf.getTipologia().toString() ),             // I valori corrispondono con con org.openspcoop2.utils.transport.http.SSLConstants
  1542.                 BaseHelper.evalorElse( () -> httpsConf.isHostnameVerifier().booleanValue(), false ),                // this.httpshostverify,
  1543.                 (httpsConf!=null ? !httpsConf.isTrustAllServerCerts() : ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS), // httpsTrustVerifyCert
  1544.                 httpsServer!=null ? evalnull( httpsServer::getTruststorePath ) : null,              // this.httpspath
  1545.                 evalnull( () -> ConnettoreHTTPApiHelper.getTruststoreType(httpsServer) ),       // this.httpstipo,
  1546.                 httpsServer!=null ? evalnull( httpsServer::getTruststorePassword ) : null,          // this.httpspwd,
  1547.                 httpsServer!=null ? evalnull( httpsServer::getAlgoritmo ) : null,                   // this.httpsalgoritmo
  1548.                 httpsstato, //
  1549.                 httpskeystore,  
  1550.                 "", //  this.httpspwdprivatekeytrust
  1551.                 httpsClient!=null ? evalnull( httpsClient::getKeystorePath ) : null,                    // httpspathkey
  1552.                 evalnull( () -> ConnettoreHTTPApiHelper.getKeystoreType(httpsClient) ),         // httpstipokey, coincide con ConnettoriCostanti.TIPOLOGIE_KEYSTORE
  1553.                 httpsClient!=null ? evalnull( httpsClient::getKeystorePassword ) : null,            // httpspwdkey
  1554.                 httpsClient!=null ? evalnull( httpsClient::getKeyPassword ) : null,                 // httpspwdprivatekey
  1555.                 httpsClient!=null ? evalnull( httpsClient::getAlgoritmo ) : null,                   // httpsalgoritmokey
  1556.                 httpsClient!=null ? evalnull( httpsClient::getKeyAlias ) : null,                    // httpsKeyAlias
  1557.                 httpsServer!=null ? evalnull( httpsServer::getTruststoreCrl ) : null,                   // httpsTrustStoreCRLs
  1558.                 httpsServer!=null ? evalnull( httpsServer::getTruststoreOcspPolicy) : null,             // httpsTrustStoreOCSPPolicy
  1559.                 httpsClient!=null ? evalnull( httpsClient::getKeystoreByokPolicy) : null,               // httpsKeyStoreBYOKPolicy
  1560.                 null,                               // tipoconn Da debug = null.    
  1561.                 asps.getVersione().toString(), //as.getVersione().toString(),       // Versione aspc
  1562.                 false,                              // validazioneDocumenti Da debug = false
  1563.                 null,                               // Da Codice console
  1564.                 ServletUtils.boolToCheckBoxStatus(http_stato),  // "yes" se utilizziamo http.
  1565.                 ServletUtils.boolToCheckBoxStatus(proxy_enabled),           
  1566.                 proxy!=null ? evalnull( proxy::getHostname ) : null,
  1567.                 evalnull( () -> proxy.getPorta().toString() ),
  1568.                 proxy!=null ? evalnull( proxy::getUsername ) : null,
  1569.                 proxy!=null ? evalnull( proxy::getPassword ) : null,                
  1570.                 ServletUtils.boolToCheckBoxStatus(tempiRisposta_enabled), 
  1571.                 evalnull( () -> timeoutConf.getConnectionTimeout().toString()),     // this.tempiRisposta_connectionTimeout, 
  1572.                 evalnull( () -> timeoutConf.getConnectionReadTimeout().toString()),  // this.tempiRisposta_readTimeout, 
  1573.                 evalnull( () -> timeoutConf.getTempoMedioRisposta().toString()),        // this.tempiRisposta_tempoMedioRisposta,
  1574.                 ServletUtils.boolToCheckBoxStatus(false),   // opzioniAvanzate 
  1575.                 "",     // transfer_mode, 
  1576.                 "",     // transfer_mode_chunk_size, 
  1577.                 "",     // redirect_mode, 
  1578.                 "",     // redirect_max_hop, 
  1579.                 null,   // requestOutputFileName,
  1580.                 null,   // requestOutputFileName_permissions,
  1581.                 null,   // requestOutputFileNameHeaders, 
  1582.                 null,   // requestOutputFileNameHeaders_permissions, 
  1583.                 null,   // requestOutputParentDirCreateIfNotExists, 
  1584.                 null,   // requestOutputOverwriteIfExists,
  1585.                 null,   // responseInputMode,
  1586.                 null,   // responseInputFileName,
  1587.                 null,   // responseInputFileNameHeaders,
  1588.                 null,   // responseInputDeleteAfterRead,
  1589.                 null,   // responseInputWaitTime,
  1590.                 null,   // erogazioneSoggetto, Come da codice console.
  1591.                 erogazioneRuolo,    //, non viene utilizzato.
  1592.                 evalnull( () -> Enums.tipoAutenticazioneFromRest.get(authn.getTipo()).toString() ),     // erogazioneAutenticazione
  1593.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( autenticazioneOpzionaleNullable!=null ? autenticazioneOpzionaleNullable.getValue() : null ) ),                   // erogazioneAutenticazioneOpzionale
  1594.                 autenticazionePrincipal, // erogazioneAutenticazionePrincipal
  1595.                 autenticazioneParametroList, // erogazioneAutenticazioneParametroList
  1596.                 statoAutorizzazione,                        // erogazioneAutorizzazione QUESTO E' lo STATO dell'autorizzazione
  1597.                 ServletUtils.boolToCheckBoxStatus( isRichiedente ),             // erogazioneAutorizzazioneAutenticati, 
  1598.                 ServletUtils.boolToCheckBoxStatus( isRuoli ),               // erogazioneAutorizzazioneRuoli, 
  1599.                 Enums.ruoloTipologiaFromRest.get(ruoliFonte).toString(),                // erogazioneAutorizzazioneRuoliTipologia,
  1600.                 ruoliRichiesti!=null ? ruoliRichiesti.toString() : null,    // erogazioneAutorizzazioneRuoliMatch,  AllAnyEnum == RuoloTipoMatch
  1601.                 env.isSupportatoAutenticazioneSoggetti, 
  1602.                 generaPortaApplicativa,                                                 // generaPACheckSoggetto (Un'erogazione genera una porta applicativa)
  1603.                 listExtendedConnettore,
  1604.                 null,                                                                   // fruizioneServizioApplicativo
  1605.                 null,                                                                   // Ruolo fruizione, non viene utilizzato.
  1606.                 evalnull( () -> Enums.tipoAutenticazioneFromRest.get(authn.getTipo()).toString() ),  // fruizioneAutenticazione 
  1607.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( autenticazioneOpzionaleNullable!=null ? autenticazioneOpzionaleNullable.getValue() : null ) ),           // fruizioneAutenticazioneOpzionale
  1608.                 autenticazionePrincipal, // fruizioneAutenticazionePrincipal
  1609.                 autenticazioneParametroList, // fruizioneAutenticazioneParametroList
  1610.                 statoAutorizzazione,                                            // fruizioneAutorizzazione  
  1611.                 ServletUtils.boolToCheckBoxStatus( isRichiedente ),                 // fruizioneAutorizzazioneAutenticati, 
  1612.                 ServletUtils.boolToCheckBoxStatus( isRuoli ),                   // fruizioneAutorizzazioneRuoli,
  1613.                 Enums.ruoloTipologiaFromRest.get(ruoliFonte).toString(),                    // fruizioneAutorizzazioneRuoliTipologia,
  1614.                 ruoliRichiesti!=null ? ruoliRichiesti.toString() : null,        // fruizioneAutorizzazioneRuoliMatch,
  1615.                 env.tipo_protocollo, 
  1616.                 xamlPolicy,                                                                 //allegatoXacmlPolicy,
  1617.                 "",
  1618.                 evalnull( () -> fruitore.get().getTipo() ),     // tipoFruitore 
  1619.                 evalnull( () -> fruitore.get().getNome() ),         // nomeFruitore
  1620.                 autenticazioneToken,
  1621.                 tokenPolicy,
  1622.                 
  1623.                 apiKey ? org.openspcoop2.web.lib.mvc.Costanti.CHECK_BOX_ENABLED : org.openspcoop2.web.lib.mvc.Costanti.CHECK_BOX_DISABLED, // autenticazioneApiKey
  1624.                 apiKey && 
  1625.                     env.erogazioniHelper.isAutenticazioneApiKeyUseOAS3Names(
  1626.                             httpApiKey!=null ? evalnull(httpApiKey::getApiKeyHeader) : null, 
  1627.                             httpApiKey!=null ? evalnull(httpApiKey::getAppIdHeader) : null
  1628.                 ), // useOAS3Names
  1629.                 apiKey && 
  1630.                     env.erogazioniHelper.isAutenticazioneApiKeyUseAppId(
  1631.                             httpApiKey!=null ? evalnull(httpApiKey::getAppId) : null
  1632.                 ), // useAppId
  1633.                 httpApiKey!=null ? evalnull( httpApiKey::getApiKeyHeader ) : null, // apiKeyHeader
  1634.                 httpApiKey!=null ? evalnull( httpApiKey::getApiKey ) : null, // apiKeyValue
  1635.                 httpApiKey!=null ? evalnull( httpApiKey::getAppIdHeader ) : null, // appIdHeader
  1636.                 httpApiKey!=null ? evalnull( httpApiKey::getAppId ) : null, // appIdValue   
  1637.                 
  1638.                 false, // erogazioneServizioApplicativoServerEnabled, 
  1639.                 null, // rogazioneServizioApplicativoServer
  1640.                 canaleStato, canale, gestioneCanaliEnabled
  1641.             )) {
  1642.             throw FaultCode.RICHIESTA_NON_VALIDA.toException( StringEscapeUtils.unescapeHtml( env.pd.getMessage()) );
  1643.         }
  1644.         
  1645.         
  1646.         
  1647.     }


  1650.     
  1651.     public static final org.openspcoop2.core.registry.Connettore buildConnettoreRegistro(final ErogazioniEnv env, final BaseConnettoreHttp conn) throws Exception {
  1652.         final org.openspcoop2.core.registry.Connettore regConnettore = new org.openspcoop2.core.registry.Connettore();
  1653.         fillConnettoreRegistro(regConnettore, env, conn, "");
  1654.         return regConnettore;
  1655.     }

  1657.     
  1658.     public static final void fillConnettoreRegistro(
  1659.             final org.openspcoop2.core.registry.Connettore regConnettore,
  1660.             final ErogazioniEnv env,
  1661.             final BaseConnettoreHttp conn,
  1662.             final String oldConnT
  1663.             ) throws Exception {
  1664.         
  1665.         
  1666.         final boolean proxy_enabled = conn.getProxy() != null;
  1667.         final boolean tempiRisposta_enabled = conn.getTempiRisposta() != null; 
  1668.         
  1669.         final ConnettoreConfigurazioneApiKey httpApiKey = conn.getAutenticazioneApikey();
  1670.         final ConnettoreConfigurazioneHttps httpsConf    = conn.getAutenticazioneHttps();
  1671.         final ConnettoreConfigurazioneHttpBasic httpConf     = conn.getAutenticazioneHttp();

  1673.         final String endpointtype = httpsConf != null ? TipiConnettore.HTTPS.getNome() : TipiConnettore.HTTP.getNome();
  1674.         
  1675.         final Properties parametersPOST = null;
  1676.         org.openspcoop2.core.registry.Connettore conTmp = null;
  1677.         List<ExtendedConnettore> listExtendedConnettore = 
  1678.                 ServletExtendedConnettoreUtils.getExtendedConnettore(conTmp, ConnettoreServletType.ACCORDO_SERVIZIO_PARTE_SPECIFICA_ADD, env.apsHelper, 
  1679.                             parametersPOST, false, endpointtype);

  1681.         final ConnettoreConfigurazioneHttpsClient httpsClient = httpsConf!=null ? evalnull( httpsConf::getClient ) : null;
  1682.         final ConnettoreConfigurazioneHttpsServer httpsServer = httpsConf!=null ? evalnull( httpsConf::getServer ) : null;
  1683.         final ConnettoreConfigurazioneProxy       proxy       = conn.getProxy();
  1684.         final ConnettoreConfigurazioneTimeout     timeoutConf = conn.getTempiRisposta();
  1685.         final String tokenPolicy = conn.getTokenPolicy(); 
  1686.         
  1687.         final boolean httpsstato = httpsClient != null; // Questo è per l'autenticazione client.
  1688.          
  1689.         String httpskeystore = ErogazioniCheckNotNull.getHttpskeystore(httpsClient);
  1690.                         
  1691.          
  1692.         env.apsHelper.fillConnettore(
  1693.                 regConnettore, 
  1694.                 conn.isDebug() != null && conn.isDebug() ? "true" : "false",                // this.connettoreDebug,
  1695.                 endpointtype,           // endpointtype
  1696.                 oldConnT,                       // oldConnT
  1697.                 "",                     // tipoConn Personalizzato
  1698.                 conn.getEndpoint(),     // this.url,
  1699.                 null,   // this.nome,
  1700.                 null,   // this.tipo,
  1701.                 httpConf!=null ? evalnull( httpConf::getUsername ) : null,
  1702.                 httpConf!=null ? evalnull( httpConf::getPassword ) : null,
  1703.                 null,   // this.initcont, 
  1704.                 null,   // this.urlpgk,
  1705.                 conn.getEndpoint(), // this.url, 
  1706.                 null,   // this.connfact,
  1707.                 null,   // this.sendas,
  1708.                 conn.getEndpoint(),                                                     // this.httpsurl, 
  1709.                 evalnull( () -> httpsConf.getTipologia().toString() ),              // this.httpstipologia
  1710.                 BaseHelper.evalorElse( () -> httpsConf.isHostnameVerifier().booleanValue(), false ),    // this.httpshostverify,
  1711.                 (httpsConf!=null ? !httpsConf.isTrustAllServerCerts() : ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS), // httpsTrustVerifyCert
  1712.                 httpsServer!=null ? evalnull( httpsServer::getTruststorePath ) : null,              // this.httpspath
  1713.                 evalnull( () -> ConnettoreHTTPApiHelper.getTruststoreType(httpsServer) ),   // this.httpstipo,
  1714.                 httpsServer!=null ? evalnull( httpsServer::getTruststorePassword ) : null,          // this.httpspwd,
  1715.                 httpsServer!=null ? evalnull( httpsServer::getAlgoritmo ) : null,                   // this.httpsalgoritmo
  1716.                 httpsstato,
  1717.                 httpskeystore,          // this.httpskeystore, 
  1718.                 "",                                                                 //  this.httpspwdprivatekeytrust
  1719.                 httpsClient!=null ? evalnull( httpsClient::getKeystorePath ) : null,                // pathkey
  1720.                 evalnull( () -> ConnettoreHTTPApiHelper.getKeystoreType(httpsClient) ),         // this.httpstipokey
  1721.                 httpsClient!=null ? evalnull( httpsClient::getKeystorePassword ) : null,            // this.httpspwdkey 
  1722.                 httpsClient!=null ? evalnull( httpsClient::getKeyPassword ) : null,             // this.httpspwdprivatekey,  
  1723.                 httpsClient!=null ? evalnull( httpsClient::getAlgoritmo ) : null,               // this.httpsalgoritmokey,
  1724.                 httpsClient!=null ? evalnull( httpsClient::getKeyAlias ) : null,                    // httpsKeyAlias
  1725.                 httpsServer!=null ? evalnull( httpsServer::getTruststoreCrl ) : null,                   // httpsTrustStoreCRLs
  1726.                 httpsServer!=null ? evalnull( httpsServer::getTruststoreOcspPolicy) : null,             // httpsTrustStoreOCSPPolicy
  1727.                 httpsClient!=null ? evalnull( httpsClient::getKeystoreByokPolicy) : null,               // httpsKeyStoreBYOKPolicy
  1728.             
  1729.                 ServletUtils.boolToCheckBoxStatus( proxy_enabled ), 
  1730.                 proxy!=null ? evalnull( proxy::getHostname ) : null,
  1731.                 evalnull( () -> proxy.getPorta().toString() ),
  1732.                 proxy!=null ? evalnull( proxy::getUsername ) : null,
  1733.                 proxy!=null ? evalnull( proxy::getPassword ) : null,
  1734.                 
  1735.                 ServletUtils.boolToCheckBoxStatus( tempiRisposta_enabled ), 
  1736.                 evalnull( () -> timeoutConf.getConnectionTimeout().toString()), // this.tempiRisposta_connectionTimeout, 
  1737.                 evalnull( () -> timeoutConf.getConnectionReadTimeout().toString()), //null, // this.tempiRisposta_readTimeout, 
  1738.                 evalnull( () -> timeoutConf.getTempoMedioRisposta().toString()),    // this.tempiRisposta_tempoMedioRisposta,
  1739.                 "no",   // this.opzioniAvanzate, 
  1740.                 "",     // this.transfer_mode, 
  1741.                 "",     // this.transfer_mode_chunk_size, 
  1742.                 "",     // this.redirect_mode, 
  1743.                 "",     // this.redirect_max_hop,
  1744.                 null,   // this.requestOutputFileName,
  1745.                 null,   // this.requestOutputFileName_permissions,
  1746.                 null,   // this.requestOutputFileNameHeaders,
  1747.                 null,   // this.requestOutputFileNameHeaders_permissions,
  1748.                 null,   // this.requestOutputParentDirCreateIfNotExists,
  1749.                 null,   // this.requestOutputOverwriteIfExists,
  1750.                 null,   // this.responseInputMode, 
  1751.                 null,   // this.responseInputFileName, 
  1752.                 null,   // this.responseInputFileNameHeaders, 
  1753.                 null,   // this.responseInputDeleteAfterRead, 
  1754.                 null,   // this.responseInputWaitTime,
  1755.                 tokenPolicy, 
  1756.                 
  1757.                 httpApiKey!=null ? evalnull( httpApiKey::getApiKeyHeader ) : null, 
  1758.                 httpApiKey!=null ? evalnull( httpApiKey::getApiKey ) : null,
  1759.                 httpApiKey!=null ? evalnull( httpApiKey::getAppIdHeader ) : null, 
  1760.                 httpApiKey!=null ? evalnull( httpApiKey::getAppId ): null, 
  1761.                 
  1762.                 null, // connettoreStatusParams
  1763.                 listExtendedConnettore);            
  1764.     }
  1765.     
  1766.     public static final void createAps(
  1767.             ErogazioniEnv env,
  1768.             AccordoServizioParteSpecifica asps,
  1769.             org.openspcoop2.core.registry.Connettore regConnettore,
  1770.             APIImpl impl,
  1771.             boolean alreadyExists,
  1772.             boolean generaPortaApplicativa) throws Exception
  1773.     {
  1774.         final boolean generaPortaDelegata = !generaPortaApplicativa;
  1775.         
  1776.         // defaults
  1777.         if (impl.getAutenticazione() == null) {
  1778.             APIImplAutenticazioneHttps https = new APIImplAutenticazioneHttps();
  1779.             https.setTipo(TipoAutenticazioneEnum.HTTPS);
  1780.             https.setOpzionale(false);
  1781.             impl.setAutenticazione(https);
  1782.         }
  1783.         
  1784.         final OneOfAPIImplAutorizzazione authz = impl.getAutorizzazione();
  1785.         final OneOfAPIImplAutenticazione authn = impl.getAutenticazione();
  1786.         
  1787.         AccordoServizioParteComuneSintetico as = null;
  1788.         if(asps!=null) {
  1789.             as = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1790.         }

  1792.         FonteEnum ruoliFonte = FonteEnum.QUALSIASI;
  1793.         
  1794.         boolean isRichiedente = false;
  1795.         boolean isRuoli = false;
  1796.         String statoAutorizzazione = AutorizzazioneUtilities.STATO_DISABILITATO;
  1797.         String soggettoAutenticato = null;
  1798.         AllAnyEnum ruoliRichiesti = null;
  1799.         String ruolo = null;
  1800.         
  1801.         TipoAutenticazionePrincipal autenticazionePrincipal = null;
  1802.         List<String> autenticazioneParametroList = null;
  1803.         if(authn!=null) {
  1804.             autenticazionePrincipal = getTipoAutenticazionePrincipal(authn); 
  1805.             autenticazioneParametroList = getAutenticazioneParametroList(env, authn.getTipo(), authn);
  1806.         }
  1807.         final org.openspcoop2.utils.BooleanNullable autenticazioneOpzionaleNullable = getAutenticazioneOpzionale(authn); // gestisce authn se null
  1808.                 
  1809.         if ( evalnull( () -> authz.getTipo() ) != null) {
  1810.             switch (authz.getTipo()) {
  1811.             case ABILITATO: 
  1812.                 
  1813.                 if(authz instanceof APIImplAutorizzazioneAbilitataNew) {
  1814.                     
  1815.                     APIImplAutorizzazioneAbilitataNew authzAbilitata = (APIImplAutorizzazioneAbilitataNew) authz;
  1816.                     
  1817.                     if(authzAbilitata.getRuoliFonte()!=null) {
  1818.                         ruoliFonte = authzAbilitata.getRuoliFonte();
  1819.                     }
  1820.                     isRichiedente = authzAbilitata.isRichiedente();
  1821.                     isRuoli = authzAbilitata.isRuoli();
  1822.                     statoAutorizzazione = AutorizzazioneUtilities.STATO_ABILITATO;
  1823.                     if ( authzAbilitata.getSoggetto() != null )
  1824.                         soggettoAutenticato = new IDSoggetto(env.tipo_soggetto, authzAbilitata.getSoggetto()).toString();
  1825.                     ruoliRichiesti = authzAbilitata.getRuoliRichiesti();
  1826.                     ruolo = authzAbilitata.getRuolo();
  1827.                 }
  1828.                 else {
  1829.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  1830.                 }
  1831.                 
  1832.                 break;
  1833.             case XACML_POLICY:
  1834.                 
  1835.                 if(authz instanceof APIImplAutorizzazioneXACML) {
  1836.                     
  1837.                     APIImplAutorizzazioneXACML authzXacml = (APIImplAutorizzazioneXACML) authz;
  1838.                 
  1839.                     if (authzXacml.getPolicy() == null) {
  1840.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Campo obbligatorio 'policy' non presente nell'autorizzazione indicata");
  1841.                     }
  1842.                     if(authzXacml.getRuoliFonte()!=null) {
  1843.                         ruoliFonte = authzXacml.getRuoliFonte();
  1844.                     }
  1845.                     statoAutorizzazione = AutorizzazioneUtilities.STATO_XACML_POLICY;
  1846.                 }
  1847.                 else {
  1848.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  1849.                 }
  1850.                 break;
  1851.             case DISABILITATO:
  1852.                 statoAutorizzazione = AutorizzazioneUtilities.STATO_DISABILITATO;
  1853.                 break;
  1854.             case CUSTOM:
  1855.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Tipo di autorizzazione '"+authz.getTipo()+"' non utilizzabile");
  1856.             }
  1857.         }
  1858.         
  1859.         
  1860.         
  1861.         IDServizio idServizio = null;
  1862.         if(asps!=null) {
  1863.             idServizio = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(), new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione());
  1864.         }
  1865.                    
  1866.         BinaryParameter xamlPolicy = new BinaryParameter();
  1867.         if(authz instanceof APIImplAutorizzazioneXACML) {
  1868.             APIImplAutorizzazioneXACML authzXacml = (APIImplAutorizzazioneXACML) authz;
  1869.             xamlPolicy.setValue(authzXacml.getPolicy());
  1870.         }
  1871.         xamlPolicy.setName(CostantiControlStation.PARAMETRO_DOCUMENTO_SICUREZZA_XACML_POLICY);
  1872.               
  1873.         boolean gestioneCanaliEnabled = env.gestioneCanali;
  1874.         String canale = null;
  1875.         if(gestioneCanaliEnabled) {
  1876.             if(impl instanceof Erogazione) {
  1877.                 canale = ((Erogazione)impl).getCanale();
  1878.             }
  1879.             else if(impl instanceof Fruizione) {
  1880.                 canale = ((Fruizione)impl).getCanale();
  1881.             }
  1882.             if(canale!=null) {
  1883.                 if(!env.canali.contains(canale)) {
  1884.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il canale fornito '" + canale + "' non è presente nel registro");
  1885.                 }
  1886.             }
  1887.         }
  1888.         String canaleStato = null;
  1889.         if(canale == null) {
  1890.             canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  1891.         } else {
  1892.             canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  1893.         }

  1895.         
  1896.         ProtocolProperties p = null;
  1897.         if(generaPortaApplicativa) {
  1898.             p = getProtocolProperties(asps, env);
  1899.         } else {
  1900.             IDFruizione idFruizione = new IDFruizione();
  1901.             
  1902.             IDServizio idAps = new IDServizio();

  1904.             if(asps!=null) {
  1905.                 idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  1906.                 idAps.setPortType(asps.getPortType());
  1907.             }

  1909.             idFruizione.setIdServizio(idAps);
  1910.             IDSoggetto idFruitore = new IDSoggetto(env.idSoggetto.getTipo(), env.idSoggetto.getNome());
  1911.             idFruizione.setIdFruitore(idFruitore);

  1913.             Fruitore fruitore = getFruitore(asps, env.idSoggetto.getNome());
  1914.             if(fruitore==null) {
  1915.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il fruitore '" + env.idSoggetto.getNome() + "' non risulta definito");
  1916.             }
  1917.             p = getProtocolProperties(idFruizione, fruitore, env);
  1918.         }
  1919.         
  1920.         AccordiServizioParteSpecificaUtilities.create(
  1921.                 asps,
  1922.                 alreadyExists, 
  1923.                 idServizio,                                         // idServizio,
  1924.                 env.idSoggetto.toIDSoggetto(),                      // idFruitore,
  1925.                 env.tipo_protocollo,                                // this.tipoProtocollo,
  1926.                 env.apcCore.toMessageServiceBinding(as.getServiceBinding()), 
  1927.                 env.idSoggetto.getId(),                             // Questo è l'id del soggetto a cui associare la porta delegata\applicativa
  1928.                 regConnettore, 
  1929.                 generaPortaApplicativa,                                     // generaPortaApplicativa,
  1930.                 generaPortaDelegata,                                        // generaPortaDelegata
  1931.                 evalnull( () -> Enums.tipoAutenticazioneFromRest.get(authn.getTipo()).toString() ),                                         // erogazioneAutenticazione
  1932.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( autenticazioneOpzionaleNullable!=null ? autenticazioneOpzionaleNullable.getValue() : null ) ),                                                       // erogazioneAutenticazioneOpzionale
  1933.                 autenticazionePrincipal, // erogazioneAutenticazionePrincipal
  1934.                 autenticazioneParametroList, // erogazioneAutenticazioneParametroList
  1935.                 statoAutorizzazione,    // autorizzazione, è lo STATO   
  1936.                 ServletUtils.boolToCheckBoxStatus( isRichiedente ),         //  autorizzazioneAutenticati,
  1937.                 ServletUtils.boolToCheckBoxStatus( isRuoli ),               //  autorizzazioneRuoli,
  1938.                 Enums.ruoloTipologiaFromRest.get(ruoliFonte).toString(),                //  erogazioneAutorizzazioneRuoliTipologia
  1939.                 ruoliRichiesti!=null ? ruoliRichiesti.toString() : null,            //  autorizzazioneRuoliMatch
  1940.                 null,   // servizioApplicativo Come da Debug, 
  1941.                 ruolo,  // ruolo: E' il ruolo scelto nella label "Ruolo" 
  1942.                 soggettoAutenticato,    // soggettoAutenticato TODO BISOGNA AGGIUNGERE IL CONTROLLO CHE IL SOGGETTO AUTENTICATO SIA NEL REGISTRO 
  1943.                 null,   //  autorizzazioneAutenticatiToken, 
  1944.                 null,   //  autorizzazioneRuoliToken, 
  1945.                 null,   //  autorizzazioneRuoliTipologiaToken, 
  1946.                 null,   //  autorizzazioneRuoliMatchToken,
  1947.                 null,   // autorizzazione_tokenOptions, 
  1948.                 null,   // autorizzazioneScope, 
  1949.                 null,   // scope, 
  1950.                 null,   // autorizzazioneScopeMatch,
  1951.                 xamlPolicy, // allegatoXacmlPolicy,
  1952.                 StatoFunzionalita.DISABILITATO.toString(),  // gestioneToken
  1953.                 null,   // gestioneTokenPolicy,
  1954.                 null,   // gestioneTokenOpzionale, 
  1955.                 null,   // gestioneTokenValidazioneInput, 
  1956.                 null,   // gestioneTokenIntrospection, 
  1957.                 null,   // gestioneTokenUserInfo, 
  1958.                 null,   // gestioneTokenTokenForward, 
  1959.                 null,   // autenticazioneTokenIssuer, 
  1960.                 null,   // autenticazioneTokenClientId,
  1961.                 null,   // autenticazioneTokenSubject, 
  1962.                 null,   // autenticazioneTokenUsername, 
  1963.                 null,   // autenticazioneTokenEMail, 
  1964.                 p, 
  1965.                 ConsoleOperationType.ADD, 
  1966.                 env.apsCore, 
  1967.                 env.erogazioniHelper,
  1968.                 null, // nomeSAServer TODO quando si aggiunge applicativo server
  1969.                 canaleStato, canale, gestioneCanaliEnabled,
  1970.                 null, // identificazioneAttributiStato, 
  1971.                 null, //String [] attributeAuthoritySelezionate
  1972.                 null // attributeAuthorityAttributi
  1973.             );

  1975.         
  1976.     }
  1977.     
  1978.     public static Fruitore getFruitore(AccordoServizioParteSpecifica asps, String nome) {
  1979.         
  1980.         if(asps!=null && asps.getFruitoreList()!=null) {
  1981.             for(Fruitore f: asps.getFruitoreList()) {
  1982.                 if(f.getNome().equals(nome)) {
  1983.                     return f;
  1984.                 }
  1985.             }
  1986.         }
  1987.         return null;
  1988.     }

  1990.     /*public static final AccordoServizioParteSpecifica getServizio(String tipo, String nome, Integer versione, IDSoggetto idErogatore, ErogazioniEnv env) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  1991.         
  1992.         
  1993.         return getServizio(nome, versione, tipo, idErogatore, env);
  1994.     }*/
  1995.     
  1996.     
  1997.     public static final AccordoServizioParteSpecifica getServizio(String tipo, String nome, Integer versione, IDSoggetto idErogatore, ErogazioniEnv env) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  1998.         
  1999.         if ( tipo == null ) {
  2000.             tipo = env.protocolFactoryMgr._getServiceTypes().get(env.tipo_protocollo).get(0);
  2001.         }       
  2002.         final IDServizio idAps = env.idServizioFactory.getIDServizioFromValues(tipo, nome, idErogatore, versione);
  2003.         
  2004.         return env.apsCore.getServizio(idAps, true);
  2005.     }
  2006.     
  2007.     
  2008.     public static final boolean isErogazione(AccordoServizioParteSpecifica asps, ErogazioniEnv env) throws DriverConfigurazioneException, DriverRegistroServiziException {
  2009.         List<IDPortaApplicativa> pApplicative = env.paCore.getIDPorteApplicativeAssociate(env.idServizioFactory.getIDServizioFromAccordo(asps));
  2010.         return pApplicative != null && !pApplicative.isEmpty();
  2011.     }
  2012.     
  2013.     public static final boolean isFruizione(AccordoServizioParteSpecifica asps, IDSoggetto idFruitore, ErogazioniEnv env) throws DriverConfigurazioneException, DriverRegistroServiziException {
  2014.         List<IDPortaDelegata> pDelegate = env.pdCore.getIDPorteDelegateAssociate(env.idServizioFactory.getIDServizioFromAccordo(asps), idFruitore);
  2015.         return pDelegate != null && !pDelegate.isEmpty();
  2016.     }
  2017.     
  2018.     
  2019.     
  2020.     
  2021.     
  2022.     public static final AccordoServizioParteSpecifica getServizioIfErogazione(String tipo, String nome, Integer versione, IDSoggetto idErogatore, ErogazioniEnv env) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2023.         
  2024.         final AccordoServizioParteSpecifica ret = getServizio(tipo, nome, versione, idErogatore, env);
  2025.         
  2026.         try {
  2027.             if (!isErogazione(ret,env)) {
  2028.                 return null;
  2029.             }
  2030.         } catch (Exception e) {
  2031.             return null;
  2032.         }
  2033.         
  2034.         return ret;
  2035.     }
  2036.     
  2037.     
  2038.     public static final AccordoServizioParteSpecifica getServizioIfFruizione(String tipo, String nome, Integer versione, IDSoggetto idErogatore, IDSoggetto idFruitore, ErogazioniEnv env) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2039.         
  2040.         final AccordoServizioParteSpecifica ret = getServizio(tipo, nome, versione, idErogatore, env);
  2041.         
  2042.         try {
  2043.             if (!isFruizione(ret,idFruitore,env))
  2044.                 return null;
  2045.         } catch (Exception e) {
  2046.             return null;
  2047.         }
  2048.         
  2049.         return ret;
  2050.     }
  2051.     
  2052. //  public static final AllegatoGenerico deserializeAllegatoGenerico(Object o) {
  2053. //      AllegatoGenerico ret = deserializeDefault(o, AllegatoGenerico.class);
  2054. //      if (StringUtils.isEmpty(ret.getNome()) || ret.getDocumento() == null) {
  2055. //          throw FaultCode.RICHIESTA_NON_VALIDA.toException(AllegatoGenerico.class.getName() + ": Indicare i campi obbligatori 'nome' e 'documento'");
  2056. //      }
  2057. //      return ret;
  2058. //  }
  2059. //  
  2060. //  public static final AllegatoSpecificaSemiformale deserializeAllegatoSpecificaSemiformale(Object o) {
  2061. //      AllegatoSpecificaSemiformale ret = deserializeDefault(o, AllegatoSpecificaSemiformale.class);
  2062. //      if (StringUtils.isEmpty(ret.getNome()) || ret.getDocumento() == null || ret.getTipo() == null) {
  2063. //          throw FaultCode.RICHIESTA_NON_VALIDA.toException(AllegatoSpecificaSemiformale.class.getName() + ": Indicare i campi obbligatori 'nome', 'documento' e 'tipo'");
  2064. //      }
  2065. //      return ret;
  2066. //  }
  2067.     
  2068.     
  2069.         
  2070.     public static final Documento implAllegatoToDocumento(ApiImplAllegato body, AccordoServizioParteSpecifica asps) throws InstantiationException, IllegalAccessException {
  2071.         
  2072.         Documento documento = new Documento();
  2073.         documento.setIdProprietarioDocumento(asps.getId());
  2074.         
  2075.         RuoloAllegatoAPIImpl ruoloAllegato = body.getAllegato().getRuolo();
  2076.         
  2077.         documento.setRuolo(RuoliDocumento.valueOf(
  2078.                 Enums.ruoliDocumentoFromApiImpl
  2079.                 .get( ruoloAllegato).toString() )
  2080.                 .toString()
  2081.             );
  2082.         
  2083.         switch (ruoloAllegato) {
  2084.         case ALLEGATO:
  2085.             
  2086.             if(! (body.getAllegato() instanceof ApiImplAllegatoGenerico)) {
  2087.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'allegato fornito possiede una struttura dati '"+body.getAllegato().getClass().getName()+"' non compatibile con il ruolo '"+ruoloAllegato+"'");
  2088.             }
  2089.             ApiImplAllegatoGenerico allegatoGenerico = (ApiImplAllegatoGenerico) body.getAllegato();
  2090.             documento.setFile(allegatoGenerico.getNome());
  2091.             documento.setByteContenuto(allegatoGenerico.getDocumento());
  2092.             documento.setTipo( evalnull( () -> allegatoGenerico.getNome().substring( allegatoGenerico.getNome().lastIndexOf('.')+1, allegatoGenerico.getNome().length())) );
  2093.             break;

  2095.         case SPECIFICASEMIFORMALE:
  2096.             
  2097.             if(! (body.getAllegato() instanceof ApiImplAllegatoSpecificaSemiformale)) {
  2098.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'allegato fornito possiede una struttura dati '"+body.getAllegato().getClass().getName()+"' non compatibile con il ruolo '"+ruoloAllegato+"'");
  2099.             }
  2100.             ApiImplAllegatoSpecificaSemiformale allegatoSS = (ApiImplAllegatoSpecificaSemiformale) body.getAllegato();
  2101.             documento.setFile(allegatoSS.getNome());
  2102.             documento.setByteContenuto(allegatoSS.getDocumento());
  2103.             if(ErogazioniCheckNotNull.isNotNullTipoSpecifica(allegatoSS, documento)) {
  2104.                 TipoSpecificaSemiformaleEnum tipoAllegato = (TipoSpecificaSemiformaleEnum) allegatoSS.getTipoSpecifica();
  2105.                 documento.setTipo( evalnull( () -> Enums.tipoDocumentoSemiFormaleFromSpecifica.get(tipoAllegato) ).toString() );
  2106.             }
  2107.             break;
  2108.             
  2109.         case SPECIFICALIVELLOSERVIZIO:
  2110.             
  2111.             if(! (body.getAllegato() instanceof ApiImplAllegatoSpecificaLivelloServizio)) {
  2112.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'allegato fornito possiede una struttura dati '"+body.getAllegato().getClass().getName()+"' non compatibile con il ruolo '"+ruoloAllegato+"'");
  2113.             }
  2114.             ApiImplAllegatoSpecificaLivelloServizio allegatoLS = (ApiImplAllegatoSpecificaLivelloServizio) body.getAllegato();
  2115.             documento.setFile(allegatoLS.getNome());
  2116.             documento.setByteContenuto(allegatoLS.getDocumento());
  2117.             if(ErogazioniCheckNotNull.isNotNullTipoSpecifica(allegatoLS, documento)) {
  2118.                 TipoSpecificaLivelloServizioEnum tipoAllegato = (TipoSpecificaLivelloServizioEnum) allegatoLS.getTipoSpecifica();
  2119.                 documento.setTipo( evalnull( () -> Enums.tipoDocumentoLivelloServizioFromSpecifica.get(tipoAllegato).toString()) );
  2120.             }
  2121.             break;
  2122.             
  2123.         case SPECIFICASICUREZZA:
  2124.             
  2125.             if(! (body.getAllegato() instanceof ApiImplAllegatoSpecificaSicurezza)) {
  2126.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'allegato fornito possiede una struttura dati '"+body.getAllegato().getClass().getName()+"' non compatibile con il ruolo '"+ruoloAllegato+"'");
  2127.             }
  2128.             ApiImplAllegatoSpecificaSicurezza allegatoSSec = (ApiImplAllegatoSpecificaSicurezza) body.getAllegato();
  2129.             documento.setFile(allegatoSSec.getNome());
  2130.             documento.setByteContenuto(allegatoSSec.getDocumento());
  2131.             if(ErogazioniCheckNotNull.isNotNullTipoSpecifica(allegatoSSec, documento)) {
  2132.                 TipoSpecificaSicurezzaEnum tipoAllegato = (TipoSpecificaSicurezzaEnum) allegatoSSec.getTipoSpecifica();
  2133.                 documento.setTipo( evalnull( () -> Enums.tipoDocumentoSicurezzaFromSpecifica.get(tipoAllegato).toString()) );
  2134.             }
  2135.             break;
  2136.         }

  2138.         return documento;
  2139.     }
  2140.     
  2141.     
  2142.     public static final ApiImplAllegato documentoToImplAllegato(Documento doc) {
  2143.         ApiImplAllegato ret = new ApiImplAllegato();
  2144.         
  2145.         RuoloAllegatoAPIImpl ruoloAllegato = Enums.ruoliApiImplFromDocumento.get( RuoliDocumento.valueOf(doc.getRuolo()));
  2146.         
  2147.         switch (ruoloAllegato) {
  2148.         case ALLEGATO: {
  2149.             
  2150.             ApiImplAllegatoGenerico allegatoGenerico = new ApiImplAllegatoGenerico();
  2151.             allegatoGenerico.setRuolo(ruoloAllegato);
  2152.             allegatoGenerico.setDocumento(doc.getByteContenuto());
  2153.             allegatoGenerico.setNome(doc.getFile());
  2154.             ret.setAllegato(allegatoGenerico);
  2155.             break;
  2156.         }
  2157.         
  2158.         case SPECIFICASEMIFORMALE: {
  2159.             
  2160.             ApiImplAllegatoSpecificaSemiformale allegatoSS = new ApiImplAllegatoSpecificaSemiformale();
  2161.             allegatoSS.setRuolo(ruoloAllegato);
  2162.             allegatoSS.setDocumento(doc.getByteContenuto());
  2163.             allegatoSS.setNome(doc.getFile());
  2164.             TipiDocumentoSemiformale tipo = TipiDocumentoSemiformale.toEnumConstant(doc.getTipo());
  2165.             allegatoSS.setTipoSpecifica((Helper.apiEnumToGovway(tipo, TipoSpecificaSemiformaleEnum.class)));
  2166.             ret.setAllegato(allegatoSS);
  2167.             break;
  2168.         }
  2169.             
  2170.         case SPECIFICALIVELLOSERVIZIO:{
  2171.             
  2172.             ApiImplAllegatoSpecificaLivelloServizio allegatoSL = new ApiImplAllegatoSpecificaLivelloServizio();
  2173.             allegatoSL.setRuolo(ruoloAllegato);
  2174.             allegatoSL.setDocumento(doc.getByteContenuto());
  2175.             allegatoSL.setNome(doc.getFile());
  2176.             TipiDocumentoLivelloServizio tipo = TipiDocumentoLivelloServizio.toEnumConstant(doc.getTipo());
  2177.             allegatoSL.setTipoSpecifica((Helper.apiEnumToGovway(tipo, TipoSpecificaLivelloServizioEnum.class)));
  2178.             ErogazioniCheckNotNull.documentoToImplAllegato(allegatoSL, tipo);
  2179.             ret.setAllegato(allegatoSL);
  2180.             break;
  2181.         }
  2182.         
  2183.         case SPECIFICASICUREZZA:{
  2184.             
  2185.             ApiImplAllegatoSpecificaSicurezza allegatoSSec = new ApiImplAllegatoSpecificaSicurezza();
  2186.             allegatoSSec.setRuolo(ruoloAllegato);
  2187.             allegatoSSec.setDocumento(doc.getByteContenuto());
  2188.             allegatoSSec.setNome(doc.getFile());
  2189.             TipiDocumentoSicurezza tipo = TipiDocumentoSicurezza.toEnumConstant(doc.getTipo());
  2190.             allegatoSSec.setTipoSpecifica((Helper.apiEnumToGovway(tipo, TipoSpecificaSicurezzaEnum.class)));
  2191.             ErogazioniCheckNotNull.documentoToImplAllegato(allegatoSSec, tipo);
  2192.             ret.setAllegato(allegatoSSec);
  2193.             break;
  2194.         }
  2195.         
  2196.         }
  2197.         
  2198.         return ret;
  2199.         
  2200.     }
  2201.     
  2202.     public static final ApiImplAllegatoItem ImplAllegatoToItem(ApiImplAllegato allegato) {
  2203.         ApiImplAllegatoItem ret = new ApiImplAllegatoItem();
  2204.         
  2205.         RuoloAllegatoAPIImpl ruoloAllegato = allegato.getAllegato().getRuolo();
  2206.         
  2207.         switch (ruoloAllegato) {
  2208.         case ALLEGATO: {
  2209.             
  2210.             ApiImplAllegatoGenerico allegatoGenerico = (ApiImplAllegatoGenerico) allegato.getAllegato();
  2211.             
  2212.             ApiImplAllegatoItemGenerico allegatoGenericoItem = new ApiImplAllegatoItemGenerico();
  2213.             allegatoGenericoItem.setRuolo(ruoloAllegato);
  2214.             allegatoGenericoItem.setNome(allegatoGenerico.getNome());
  2215.             ret.setAllegato(allegatoGenericoItem);
  2216.             break;
  2217.         }
  2218.         
  2219.         case SPECIFICASEMIFORMALE: {
  2220.             
  2221.             ApiImplAllegatoSpecificaSemiformale allegatoSS = (ApiImplAllegatoSpecificaSemiformale) allegato.getAllegato();
  2222.             
  2223.             ApiImplAllegatoItemSpecificaSemiformale allegatoItemSS = new ApiImplAllegatoItemSpecificaSemiformale();
  2224.             allegatoItemSS.setRuolo(ruoloAllegato);
  2225.             allegatoItemSS.setNome(allegatoSS.getNome());
  2226.             allegatoItemSS.setTipoSpecifica(allegatoSS.getTipoSpecifica());
  2227.             ret.setAllegato(allegatoItemSS);
  2228.             break;
  2229.         }
  2230.             
  2231.         case SPECIFICALIVELLOSERVIZIO:{
  2232.             
  2233.             ApiImplAllegatoSpecificaLivelloServizio allegatoSL = (ApiImplAllegatoSpecificaLivelloServizio) allegato.getAllegato();
  2234.             
  2235.             ApiImplAllegatoItemSpecificaLivelloServizio allegatoItemSL = new ApiImplAllegatoItemSpecificaLivelloServizio();
  2236.             allegatoItemSL.setRuolo(ruoloAllegato);
  2237.             allegatoItemSL.setNome(allegatoSL.getNome());
  2238.             allegatoItemSL.setTipoSpecifica(allegatoSL.getTipoSpecifica());
  2239.             ret.setAllegato(allegatoItemSL);
  2240.             break;
  2241.         }
  2242.         
  2243.         case SPECIFICASICUREZZA:{
  2244.             
  2245.             ApiImplAllegatoSpecificaSicurezza allegatoSSec = (ApiImplAllegatoSpecificaSicurezza) allegato.getAllegato();
  2246.             
  2247.             ApiImplAllegatoItemSpecificaSicurezza allegatoItemSSec = new ApiImplAllegatoItemSpecificaSicurezza();
  2248.             allegatoItemSSec.setRuolo(ruoloAllegato);
  2249.             allegatoItemSSec.setNome(allegatoSSec.getNome());
  2250.             allegatoItemSSec.setTipoSpecifica(allegatoSSec.getTipoSpecifica());
  2251.             ret.setAllegato(allegatoItemSSec);
  2252.             break;
  2253.         }
  2254.         
  2255.         }

  2257.         return ret;
  2258.         
  2259.     }
  2260.     
  2261.     public static void createAllegatoAsps(ApiImplAllegato body, final ErogazioniEnv env,
  2262.             AccordoServizioParteSpecifica asps) 
  2263.                     throws Exception {

  2265.         Documento documento = ErogazioniApiHelper.implAllegatoToDocumento(body, asps);
  2266.         
  2267.         SerialiableFormFile filewrap = new SerialiableFormFile(documento.getFile(), documento.getByteContenuto());
  2268.         env.requestWrapper.overrideParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_RUOLO, documento.getRuolo());            

  2270.         boolean documentoUnivocoIndipendentementeTipo = true;
  2271.         if (env.archiviCore.existsDocumento(documento,ProprietariDocumento.servizio,documentoUnivocoIndipendentementeTipo)) {
  2272.             throw FaultCode.CONFLITTO.toException("Allegato con nome " + documento.getFile() + " già presente per l'erogazione");
  2273.         }
  2274.         
  2275.         if (!env.apsHelper.serviziAllegatiCheckData(TipoOperazione.ADD,filewrap,documento,env.protocolFactory)) {
  2276.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2277.         }
  2278.         
  2279.         switch (body.getAllegato().getRuolo()) {
  2280.             case ALLEGATO:
  2281.                 asps.addAllegato(documento);
  2282.                 break;
  2283.             case SPECIFICASEMIFORMALE:
  2284.                 asps.addSpecificaSemiformale(documento);
  2285.                 break;
  2286.             case SPECIFICASICUREZZA:
  2287.                 asps.addSpecificaSicurezza(documento);
  2288.                 break;
  2289.             case SPECIFICALIVELLOSERVIZIO:
  2290.                 asps.addSpecificaLivelloServizio(documento);
  2291.                 break;
  2292.         }

  2294.         env.apsCore.performUpdateOperation(env.userLogin, false, asps);
  2295.     }
  2296.     
  2297.     public static final Optional<Documento> getDocumento(List<Documento> list, String name) {
  2298.         return list.stream().filter(d -> d.getFile().equals(name)).findFirst();
  2299.         
  2300.     }
  2301.     
  2302.     public static final Optional<Long> getIdDocumento(List<Documento> list, String name) {
  2303.         return list.stream().filter(d -> d.getFile().equals(name)).findFirst().map( d -> d.getId());
  2304.     }
  2305.     
  2306.     public static final <T> Stream<T> mergeStreams(Stream<T>[] streams) {
  2307.         Stream<T> tmp = streams[0];
  2308.         
  2309.         for(int i = 1; i< streams.length; i++) {
  2310.             tmp = Stream.concat(tmp, streams[i]);
  2311.         }
  2312.         
  2313.         return tmp;
  2314.     }
  2315.     
  2316.     public static final Optional<Long> getIdDocumento(String nomeAllegato, final AccordoServizioParteSpecifica asps) {
  2317.         Optional<Long> idDoc = ErogazioniApiHelper.getIdDocumento(asps.getSpecificaSemiformaleList(), nomeAllegato);
  2318.         
  2319.         if (!idDoc.isPresent()) idDoc = getIdDocumento(asps.getSpecificaLivelloServizioList(), nomeAllegato);
  2320.         if (!idDoc.isPresent()) idDoc = getIdDocumento(asps.getAllegatoList(), nomeAllegato);
  2321.         if (!idDoc.isPresent()) idDoc = getIdDocumento(asps.getSpecificaSicurezzaList(), nomeAllegato);
  2322.         return idDoc;
  2323.     }
  2324.     
  2325.     
  2326.     public static void updateAllegatoAsps(ApiImplAllegato body, String nomeAllegato, ErogazioniEnv env, AccordoServizioParteSpecifica asps)
  2327.             throws Exception {
  2328.         Documento oldDoc = BaseHelper.supplyOrNotFound( () -> env.archiviCore.getDocumento(nomeAllegato, null, null, asps.getId(), false, ProprietariDocumento.servizio), "Allegato di nome " + nomeAllegato); 
  2329.         
  2330.         Documento newDoc = ErogazioniApiHelper.implAllegatoToDocumento(body, asps);
  2331.         newDoc.setId(oldDoc.getId());
  2332.         newDoc.setOraRegistrazione(new Date());
  2333.         
  2334.         if (! StringUtils.equals(newDoc.getRuolo(), oldDoc.getRuolo())) {
  2335.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non puoi modificare il ruolo di un allegato");
  2336.         }

  2338.         SerialiableFormFile filewrap = new SerialiableFormFile(newDoc.getFile(), newDoc.getByteContenuto());
  2339.         env.requestWrapper.overrideParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_RUOLO, newDoc.getRuolo());
  2340.         
  2341.         if (!env.apsHelper.serviziAllegatiCheckData(TipoOperazione.CHANGE,filewrap,newDoc,env.protocolFactory)) {
  2342.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2343.         }
  2344.         
  2345.         AccordiServizioParteSpecificaUtilities.sostituisciDocumentoAsps(asps, oldDoc, newDoc);


  2348.         env.apsCore.performUpdateOperation(env.userLogin, false, asps);
  2349.     }
  2350.     
  2351.     public static final void updateInformazioniGenerali(ApiImplInformazioniGenerali body, ErogazioniEnv env, AccordoServizioParteSpecifica asps, boolean isErogazione) throws Exception{

  2353.         AccordoServizioParteComuneSintetico as = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());

  2355.         ServiceBinding tipoApi = as.getServiceBinding();
  2356.         
  2357.         IDServizio oldIDServizioForUpdate = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2358.         asps.setOldIDServizioForUpdate(oldIDServizioForUpdate);
  2359.         
  2360.         asps.setNome(body.getNome());
  2361.         if (!StringUtils.isEmpty(body.getTipo())) {
  2362.             asps.setTipo(body.getTipo());
  2363.         }
  2364.         
  2365.         if (tipoApi == ServiceBinding.SOAP && !StringUtils.isEmpty(body.getApiSoapServizio())) {
  2366.             asps.setPortType(body.getApiSoapServizio());
  2367.         }
  2368.         
  2369.         serviziUpdateCheckData(as, asps, isErogazione, env);
  2370.                         
  2371.         List<Object> oggettiDaAggiornare = AccordiServizioParteSpecificaUtilities.getOggettiDaAggiornare(asps, env.apsCore);
  2372.         
  2373.         // eseguo l'aggiornamento
  2374.         env.apsCore.performUpdateOperation(env.userLogin, false, oggettiDaAggiornare.toArray());
  2375.     }
  2376.     
  2377.     public static final void overrideFruizioneUrlInvocazione(final HttpRequestWrapper wrap, final IDSoggetto idErogatore,
  2378.             final IDServizio idServizio, final PortaDelegata pd, final PortaDelegataAzione pdAzione, boolean setPattern, long idAzione) {
  2379.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, pd.getId().toString());
  2380.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_NOME_PORTA, pd.getNome());            
  2381.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, pd.getIdSoggetto().toString());  
  2382.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_AZIONE, setPattern ? pdAzione.getPattern() : pdAzione.getNome());         // Azione è il contenuto del campo pattern o del campo nome, che vengono settati nel campo pattern.
  2383.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_AZIONE_ID, null);                     // Come da debug
  2384.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_MODE_AZIONE, pdAzione.getIdentificazione().toString() );
  2385.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_XSD, null);
  2386.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_INTEGRAZIONE, "");
  2387.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_SOGGETTO_ID, idErogatore.toString()); // Questo è il nome (uri) del soggetto erogatore
  2388.         wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_SERVIZIO_ID, idServizio.toString());
  2389.         if(idAzione>0) {
  2390.             wrap.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_AZIONE_ID, idAzione+"");
  2391.         }
  2392.     }
  2393.     
  2394.     public static final void fillApiImplViewItemWithErogazione(final ErogazioniEnv env, final AccordoServizioParteSpecifica asps, final ApiImplViewItem toFill) {
  2395.         try {
  2396.             IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2397.             AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  2398.         
  2399.             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = env.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  2400.             List<PortaApplicativa> listaPorteApplicativeAssociate = new ArrayList<>();

  2402.             String nomePortaDefault = null;
  2403.             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  2404.                 if(mappinErogazione.isDefault()) {
  2405.                     nomePortaDefault = mappinErogazione.getIdPortaApplicativa().getNome();
  2406.                 }
  2407.                 listaPorteApplicativeAssociate.add(env.paCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa()));
  2408.             }
  2409.             
  2410.             IDPortaApplicativa idPAdefault = new IDPortaApplicativa();
  2411.             idPAdefault.setNome(nomePortaDefault);
  2412.             PortaApplicativa paDefault = env.paCore.getPortaApplicativa(idPAdefault);

  2414.             int numeroAbilitate = 0;
  2415.             int numeroConfigurazioni = listaMappingErogazionePortaApplicativa.size();
  2416.             int numeroConfigurazioniSchedulingDisabilitato = -1;
  2417.             boolean allActionRedefined = false;
  2418.                         
  2419.             if(listaMappingErogazionePortaApplicativa.size()>1) {
  2420.                 List<String> azioniL = new ArrayList<>();
  2421.                 Map<String,String> azioni = env.paCore.getAzioniConLabel(asps, apc, false, true, new ArrayList<>());
  2422.                 if(azioni != null && azioni.size() > 0)
  2423.                     azioniL.addAll(azioni.keySet());
  2424.                 allActionRedefined = env.erogazioniHelper.allActionsRedefinedMappingErogazione(azioniL, listaMappingErogazionePortaApplicativa);
  2425.             }

  2427.             boolean isRidefinito = false;
  2428.             for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  2429.                 boolean statoPA = paAssociata.getStato().equals(StatoFunzionalita.ABILITATO);
  2430.                 if(statoPA) {
  2431.                     if(!allActionRedefined || !paAssociata.getNome().equals(nomePortaDefault)) {
  2432.                         numeroAbilitate ++;
  2433.                     }
  2434.                 }
  2435.                 
  2436.                 if(allActionRedefined && paAssociata.getNome().equals(nomePortaDefault)) {
  2437.                     // se tutte le azioni sono state ridefinite non devo controllare la porta di default
  2438.                     continue;
  2439.                 }

  2441.                 if(!paAssociata.getNome().equals(nomePortaDefault) && env.apsHelper.isConnettoreRidefinito(paDefault, paDefault.getServizioApplicativoList().get(0), paAssociata, 
  2442.                         paAssociata.getServizioApplicativoList().get(0), paAssociata.getServizioApplicativoList())) {
  2443.                     isRidefinito = true;
  2444.                 }
  2445.                 
  2446.                 if(paAssociata.getBehaviour()!=null && paAssociata.sizeServizioApplicativoList()>0) {
  2447.                     for (PortaApplicativaServizioApplicativo paSA : paAssociata.getServizioApplicativoList()) {
  2448.                         if(paSA!=null && paSA.getDatiConnettore()!=null && 
  2449.                                 StatoFunzionalita.DISABILITATO.equals(paSA.getDatiConnettore().getScheduling())) {
  2450.                             numeroConfigurazioniSchedulingDisabilitato++;
  2451.                         }
  2452.                     }
  2453.                 }
  2454.             }
  2455.             
  2456.             StatoDescrizione stato = getStatoDescrizione(numeroAbilitate, allActionRedefined, numeroConfigurazioni, numeroConfigurazioniSchedulingDisabilitato );
  2457.             
  2458.             ApiCanale canale = ErogazioniApiHelper.toApiCanale(env, paDefault, apc, false);
  2459.             
  2460.             String urlConnettore = ConnettoreAPIHelper.getUrlConnettore(getServizioApplicativoErogazione(idServizio, env.saCore, env.paCore, env.paHelper), isRidefinito);
  2461.             fillApiImplViewItemWithAsps(
  2462.                     env, 
  2463.                     asps, 
  2464.                     toFill, 
  2465.                     getUrlInvocazioneErogazione(asps, env),
  2466.                     urlConnettore,
  2467.                     getGestioneCorsFromErogazione(asps, env),
  2468.                     idServizio.getSoggettoErogatore().getNome(),
  2469.                     stato.stato,
  2470.                     stato.descrizione,
  2471.                     canale
  2472.                 );
  2473.             
  2474.         } catch (Exception e) {
  2475.             throw new RuntimeException(e);
  2476.         }
  2477.             
  2478.     }
  2479.     
  2480.     public static final StatoDescrizione getStatoDescrizione(int numeroAbilitate, boolean allActionRedefined, int numeroConfigurazioni, int numeroConfigurazioniSchedulingDisabilitato ) {
  2481.         String stato_descrizione;
  2482.         StatoApiEnum statoApi;
  2483.         
  2484.         StatoDescrizione ret = new StatoDescrizione();
  2485.         
  2486.         if(numeroAbilitate == 0) {
  2487.             statoApi = StatoApiEnum.ERROR;
  2488.             stato_descrizione = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_DISABILITATE_TOOLTIP;
  2489.         } else if( 
  2490.                 (!allActionRedefined && numeroAbilitate == numeroConfigurazioni) 
  2491.                 ||
  2492.                 (allActionRedefined && numeroAbilitate == (numeroConfigurazioni-1)) // escludo la regola che non viene usata poiche' tutte le azioni sono ridefinite 
  2493.                 ) {
  2494.             if(numeroConfigurazioniSchedulingDisabilitato>0) {
  2495.                 statoApi = StatoApiEnum.WARN;
  2496.                 stato_descrizione = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONNETTORI_MULTIPLI_SCHEDULING_DISABILITATO_TOOLTIP;
  2497.             }
  2498.             else {
  2499.                 statoApi = StatoApiEnum.OK;
  2500.                 stato_descrizione = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_ABILITATE_TOOLTIP; 
  2501.             }
  2502.         } else  {
  2503.             statoApi = StatoApiEnum.WARN;
  2504.             stato_descrizione = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_PARZIALMENTE_ABILITATE_TOOLTIP;
  2505.         }
  2506.         
  2507.         ret.stato = statoApi;
  2508.         ret.descrizione = stato_descrizione;
  2509.         
  2510.         return ret;
  2511.     }
  2512.     
  2513.     
  2514.     public static final void fillApiImplViewItemWithFruizione(final ErogazioniEnv env, final AccordoServizioParteSpecifica asps, final IdSoggetto fruitore, final ApiImplViewItem toFill) throws Exception {
  2515.         
  2516.         IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2517.         AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  2518.         
  2519.         long idFruizione = env.apsCore.getIdFruizioneAccordoServizioParteSpecifica(fruitore.toIDSoggetto(), idServizio);
  2520.         List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata = env.apsCore.serviziFruitoriMappingList(idFruizione, fruitore.toIDSoggetto(), idServizio, null); 
  2521.         List<PortaDelegata> listaPorteDelegateAssociate = new ArrayList<>();

  2523.         String nomePortaDefault = null;
  2524.         boolean isRidefinito = false;

  2526.         for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  2527.             if(mappingFruizione.isDefault()) {
  2528.                 nomePortaDefault = mappingFruizione.getIdPortaDelegata().getNome();
  2529.             } else {
  2530.                 
  2531.                 PortaDelegata pd = env.pdCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata());

  2533.                 List<String> listaAzioniPDAssociataMappingNonDefault = pd.getAzione().getAzioneDelegataList();
  2534.                 String azioneConnettore =  null;
  2535.                 if(listaAzioniPDAssociataMappingNonDefault!=null && listaAzioniPDAssociataMappingNonDefault.size()>0) {
  2536.                     azioneConnettore = listaAzioniPDAssociataMappingNonDefault.get(0);
  2537.                 }

  2539.                 Optional<Fruitore> fruit = BaseHelper.findFirst(asps.getFruitoreList(),
  2540.                         f -> f.getTipo().equals(mappingFruizione.getIdFruitore().getTipo()) && f.getNome().equals(mappingFruizione.getIdFruitore().getNome()));

  2542.                 if(fruit.isPresent()) {
  2543.                     if(azioneConnettore!=null && !"".equals(azioneConnettore)) {
  2544.                         for (ConfigurazioneServizioAzione check : fruit.get().getConfigurazioneAzioneList()) {
  2545.                             if(check.getAzioneList().contains(azioneConnettore)) {
  2546.                                 isRidefinito = true;
  2547.                             }
  2548.                         }
  2549.                     }
  2550.                 }
  2551.             }
  2552.             listaPorteDelegateAssociate.add(env.pdCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata()));
  2553.         }
  2554.         
  2555.         int numeroAbilitate = 0;
  2556.         int numeroConfigurazioni = listaMappingFruzionePortaDelegata.size();
  2557.         boolean allActionRedefined = false;
  2558.          
  2559.         if(listaMappingFruzionePortaDelegata.size()>1) {
  2560.             List<String> azioniL = new ArrayList<>();
  2561.             Map<String,String> azioni = env.pdCore.getAzioniConLabel(asps, apc, false, true, new ArrayList<>());
  2562.             if(azioni != null && azioni.size() > 0)
  2563.                 azioniL.addAll(azioni.keySet());
  2564.             allActionRedefined = env.erogazioniHelper.allActionsRedefinedMappingFruizione(azioniL, listaMappingFruzionePortaDelegata);
  2565.         }
  2566.         
  2567.         for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  2568.             boolean statoPD = pdAssociata.getStato().equals(StatoFunzionalita.ABILITATO);
  2569.             if(statoPD) {
  2570.                 if(!allActionRedefined || !pdAssociata.getNome().equals(nomePortaDefault)) {
  2571.                     numeroAbilitate ++;
  2572.                 }
  2573.             }
  2574.             
  2575.             if(allActionRedefined && pdAssociata.getNome().equals(nomePortaDefault)) {
  2576.                 // se tutte le azioni sono state ridefinite non devo controllare la porta di default
  2577.                 continue;
  2578.             }
  2579.             
  2580.             // aggiungere qua eventuali altri check
  2581.         }
  2582.         
  2583.         StatoDescrizione stato = getStatoDescrizione(numeroAbilitate, allActionRedefined, numeroConfigurazioni, -1);        
  2584.         
  2585.         IDPortaDelegata idPDdefault = new IDPortaDelegata();
  2586.         idPDdefault.setNome(nomePortaDefault);
  2587.         PortaDelegata pdDefault = env.pdCore.getPortaDelegata(idPDdefault);
  2588.         ApiCanale canale = ErogazioniApiHelper.toApiCanale(env, pdDefault, apc, false);
  2589.         
  2590.         try {
  2591.             String connettore = ConnettoreAPIHelper.getUrlConnettore(evalnull( () -> getConnettoreFruizione(asps, fruitore, env)), isRidefinito);
  2592.             fillApiImplViewItemWithAsps(
  2593.                     env, 
  2594.                     asps, 
  2595.                     toFill, 
  2596.                     getUrlInvocazioneFruizione(asps, fruitore.toIDSoggetto(), env),
  2597.                     connettore,
  2598.                     getGestioneCorsFromFruizione(asps, fruitore.toIDSoggetto(), env),
  2599.                     fruitore.getNome(),
  2600.                     stato.stato,
  2601.                     stato.descrizione,
  2602.                     canale
  2603.                 );
  2604.         } catch (Exception e) {
  2605.             throw new RuntimeException(e);
  2606.         }
  2607.         
  2608.     }
  2609.     
  2610.     
  2611.     public static final void fillApiImplViewItemWithAsps(
  2612.             final ErogazioniEnv env,
  2613.             final AccordoServizioParteSpecifica asps,
  2614.             final ApiImplViewItem toFill, 
  2615.             final String urlInvocazione, 
  2616.             final String urlConnettore,
  2617.             final CorsConfigurazione gestioneCors,
  2618.             final String nomeSoggetto,
  2619.             final StatoApiEnum stato,
  2620.             final String statoDescrizione,
  2621.             final ApiCanale canale) {

  2623.         try {
  2624.             final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2625.             final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  2626.             
  2627.             toFill.setTipoServizio(idServizio.getTipo());
  2628.             toFill.setNome(asps.getNome());
  2629.             toFill.setVersione(asps.getVersione());
  2630.             toFill.setSoggetto(nomeSoggetto);   // Questo nelle fruizioni è il fruitore, nelle erogazioni è l'erogatore
  2631.             toFill.setApiNome(aspc.getNome());
  2632.             toFill.setApiTipo(TipoApiEnum.valueOf(aspc.getServiceBinding().name()));
  2633.             toFill.setApiVersione(aspc.getVersione());
  2634.             toFill.setProfilo(env.profilo);
  2635.             toFill.setConnettore(urlConnettore);        
  2636.             toFill.setApiSoapServizio(asps.getPortType());
  2637.             toFill.setGestioneCors(Helper.boolToStatoFunzionalita(gestioneCors != null).toString());
  2638.             toFill.setUrlInvocazione(urlInvocazione);
  2639.             
  2640.             if(aspc.getGruppo()!=null && !aspc.getGruppo().isEmpty()) {
  2641.                 toFill.setApiTags(new ArrayList<>());
  2642.                 for (GruppoSintetico tag : aspc.getGruppo()) {
  2643.                     toFill.addApiTagsItem(tag.getNome());
  2644.                 }
  2645.             }
  2646.             
  2647.             /*if(numeroAbilitate == 0) {
  2648.                 de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_DISABILITATE);
  2649.                 de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_DISABILITATE_TOOLTIP);
  2650.             } else if( 
  2651.                     (!allActionRedefined && numeroAbilitate == numeroConfigurazioni) 
  2652.                     ||
  2653.                     (allActionRedefined && numeroAbilitate == (numeroConfigurazioni-1)) // escludo la regola che non viene usata poiche' tutte le azioni sono ridefinite 
  2654.                     ) {
  2655.                 de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_ABILITATE);
  2656.                 de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_ABILITATE_TOOLTIP);
  2657.             } else  {
  2658.                 de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_PARZIALMENTE_ABILITATE);
  2659.                 de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_PARZIALMENTE_ABILITATE_TOOLTIP);
  2660.             }*/
  2661.             
  2662.             toFill.setStato(stato);
  2663.             toFill.setStatoDescrizione(statoDescrizione);
  2664.             toFill.setCanale(canale);

  2666.         } catch (Exception e) {
  2667.             throw new RuntimeException(e);
  2668.         }       
  2669.     }
  2670.     
  2671.     
  2672.     public static final ErogazioneViewItem aspsToErogazioneViewItem(final ErogazioniEnv env, final AccordoServizioParteSpecifica asps) {
  2673.         ErogazioneViewItem ret = new ErogazioneViewItem();
  2674.         fillApiImplViewItemWithErogazione(env, asps, ret);
  2675.         return ret;
  2676.     }
  2677.     
  2678.     
  2679.     public static final FruizioneViewItem aspsToFruizioneViewItem(final ErogazioniEnv env, final AccordoServizioParteSpecifica asps, final IdSoggetto fruitore) {

  2681.         FruizioneViewItem ret = new FruizioneViewItem();
  2682.         try {
  2683.             fillApiImplViewItemWithFruizione(env, asps, fruitore, ret);
  2684.             
  2685.             final IDSoggetto idErogatore = env.idServizioFactory.getIDServizioFromAccordo(asps).getSoggettoErogatore(); 
  2686.             ret.setErogatore(idErogatore.getNome());
  2687.         } catch (Exception e) {
  2688.             throw new RuntimeException(e);
  2689.         }
  2690.         
  2691.         return ret;
  2692.     }
  2693.     
  2694.     
  2695.     public static final void fillApiImplItemFromView(ApiImplViewItem impl, ApiImplItem toFill) {
  2696.         toFill.setApiNome(impl.getApiNome());
  2697.         toFill.setApiSoapServizio(impl.getApiSoapServizio());
  2698.         toFill.setApiTipo(impl.getApiTipo());
  2699.         toFill.setApiVersione(impl.getApiVersione());
  2700.         toFill.setNome(impl.getNome());
  2701.         toFill.setProfilo(impl.getProfilo());
  2702.         toFill.setSoggetto(impl.getSoggetto());
  2703.         toFill.setStato(impl.getStato());
  2704.         toFill.setStatoDescrizione(impl.getStatoDescrizione());
  2705.         toFill.setTipoServizio(impl.getTipoServizio());
  2706.         toFill.setVersione(impl.getVersione());
  2707.         toFill.setApiTags(impl.getApiTags());
  2708.         toFill.setCanale(impl.getCanale());
  2709.     }
  2710.     
  2711.     
  2712.     public static final FruizioneItem fruizioneViewItemToFruizioneItem(FruizioneViewItem fru) {
  2713.         FruizioneItem ret = new FruizioneItem();
  2714.         fillApiImplItemFromView(fru, ret);
  2715.         ret.setErogatore(fru.getErogatore());
  2716.         return ret;
  2717.     }
  2718.     
  2719.     
  2720.     public static final ErogazioneItem erogazioneViewItemToErogazioneItem(ErogazioneViewItem ero) {
  2721.         ErogazioneItem ret = new ErogazioneItem();
  2722.         fillApiImplItemFromView(ero, ret);
  2723.         
  2724.         return ret;     
  2725.     }
  2726.     
  2727.     
  2728.     
  2729.     public static final void deleteAllegato(String nomeAllegato, final ErogazioniEnv env, final AccordoServizioParteSpecifica asps)
  2730.             throws Exception {
  2731.         final Optional<Long> idDoc = ErogazioniApiHelper.getIdDocumento(nomeAllegato, asps);
  2732.         
  2733.         if ( env.delete_404 && !idDoc.isPresent() ) {
  2734.             throw FaultCode.NOT_FOUND.toException("Allegato di nome " + nomeAllegato + " non presente."); 
  2735.         }
  2736.         
  2737.         if (idDoc.isPresent()) {
  2738.             AccordiServizioParteSpecificaUtilities.deleteAccordoServizioParteSpecificaAllegati(asps, env.userLogin, env.apsCore, env.apsHelper, Arrays.asList(idDoc.get()));
  2739.         }
  2740.     }
  2741.     
  2742.     
  2743.     public static final CorsConfigurazione getGestioneCorsFromErogazione(AccordoServizioParteSpecifica asps, ErogazioniEnv env) 
  2744.             throws DriverConfigurazioneException, DriverRegistroServiziException, DriverConfigurazioneNotFound, CoreException  {
  2745.         
  2746.         final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2747.         final IDPortaApplicativa idPA = env.paCore.getIDPortaApplicativaAssociataDefault(idServizio);
  2748.         final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPA);
  2749.         
  2750.         return pa.getGestioneCors();
  2751.     }
  2752.     
  2753.     
  2754.     public static final CorsConfigurazione getGestioneCorsFromFruizione(AccordoServizioParteSpecifica asps, IDSoggetto fruitore, ErogazioniEnv env) 
  2755.             throws DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2756.         
  2757.         final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2758.         final IDPortaDelegata idPD = env.pdCore.getIDPortaDelegataAssociataDefault(idServizio, fruitore);
  2759.         final PortaDelegata pd = env.pdCore.getPortaDelegata(idPD);

  2761.         return pd.getGestioneCors();
  2762.     }
  2763.     
  2764.     
  2765.     public static final InvocazioneServizio getInvocazioneServizioErogazione(IDServizio idServizio, ServiziApplicativiCore saCore, PorteApplicativeCore paCore, PorteApplicativeHelper paHelper) 
  2766.             throws DriverConfigurazioneNotFound, DriverConfigurazioneException, CoreException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2767.     
  2768.         ServizioApplicativo sa = getServizioApplicativoErogazione(idServizio, saCore, paCore, paHelper);
  2769.                         
  2770.         return sa.getInvocazioneServizio();
  2771.     }
  2772.     
  2773.     public static final ServizioApplicativo getServizioApplicativoErogazione(IDServizio idServizio, ServiziApplicativiCore saCore, PorteApplicativeCore paCore, PorteApplicativeHelper paHelper) 
  2774.             throws DriverConfigurazioneNotFound, DriverConfigurazioneException, CoreException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2775.     
  2776.         final IDPortaApplicativa idPA = paCore.getIDPortaApplicativaAssociataDefault(idServizio);
  2777.         PortaApplicativa pa = paCore.getPortaApplicativa(idPA);
  2778.         String nomeSaDefault = idPA.getNome();
  2779.         if(pa.sizeServizioApplicativoList()>0) {
  2780.             for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  2781.                 if(paHelper.isConnettoreDefault(pasa)) {
  2782.                     nomeSaDefault = pasa.getNome();
  2783.                     break;
  2784.                 }
  2785.             }
  2786.         }
  2787.         return saCore.getServizioApplicativo(saCore.getIdServizioApplicativo(idServizio.getSoggettoErogatore(), nomeSaDefault));
  2788.     }
  2789.     
  2790.     public static final InvocazioneServizio getInvocazioneServizioErogazioneGruppo(IdServizio idAsps, IDServizio idServizio, ErogazioniEnv env, String gruppo) 
  2791.             throws DriverConfigurazioneNotFound, DriverConfigurazioneException, CoreException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2792.     
  2793.         final ServizioApplicativo sa = getServizioApplicativo(idAsps, idServizio, env, gruppo);
  2794.         return sa.getInvocazioneServizio();

  2796.     }
  2797.     
  2798.     public static final ServizioApplicativo getServizioApplicativo(IdServizio idAsps, IDServizio idServizio, ErogazioniEnv env, String gruppo) 
  2799.             throws DriverConfigurazioneNotFound, DriverConfigurazioneException, CoreException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2800.     
  2801.         IDPortaApplicativa idPaDefault = env.paCore.getIDPortaApplicativaAssociataDefault(idServizio);
  2802.         PortaApplicativa paDefault = env.paCore.getPortaApplicativa(idPaDefault);

  2804.         final IDPortaApplicativa idPA = (gruppo!=null) ? BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPA(gruppo, idAsps, env.apsCore), "Gruppo per l'erogazione scelta") : idPaDefault;
  2805.         final PortaApplicativa pa = (gruppo!=null) ? env.paCore.getPortaApplicativa(idPA): paDefault;
  2806.         
  2807.         final ServizioApplicativo sa;
  2808.         
  2809.         boolean isConnettoreRidefinito = false;
  2810.         try {
  2811.             if(gruppo!=null) {
  2812.                 isConnettoreRidefinito = env.apsHelper.isConnettoreRidefinito(paDefault, paDefault.getServizioApplicativoList().get(0), pa, 
  2813.                         pa.getServizioApplicativoList().get(0), pa.getServizioApplicativoList());
  2814.             }
  2815.         }catch(Exception e) {
  2816.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2817.         }
  2818.         
  2819.         if(gruppo != null && isConnettoreRidefinito) {
  2820.             sa = env.saCore.getServizioApplicativo(env.saCore.getIdServizioApplicativo(idServizio.getSoggettoErogatore(), pa.getServizioApplicativoList().get(0).getNome()));
  2821.         } else {
  2822.             sa = env.saCore.getServizioApplicativo(env.saCore.getIdServizioApplicativo(idServizio.getSoggettoErogatore(), paDefault.getServizioApplicativoList().get(0).getNome()));
  2823.         }
  2824.         
  2825.         return sa;

  2827.     }
  2828.     
  2829.     public static final org.openspcoop2.core.registry.Connettore getConnettoreFruizione(AccordoServizioParteSpecifica asps, IdSoggetto fruitore, ErogazioniEnv env) {
  2830.         
  2831.         return asps.getFruitoreList().stream()
  2832.             .filter( f -> {
  2833.                 try {
  2834.                     return (new IDSoggetto(f.getTipo(), f.getNome()).equals(fruitore.toIDSoggetto())) && (f.getConnettore() != null);
  2835.                 } catch (CoreException e) {
  2836.                     throw new RuntimeException(e);
  2837.                 }
  2838.             })
  2839.             .map( f -> {
  2840.                 org.openspcoop2.core.registry.Connettore conn = f.getConnettore();
  2841.                 return conn;
  2842.             })
  2843.             .findFirst()
  2844.             .orElse(null);
  2845.                     
  2846.     }
  2847.     
  2848.     
  2849.     public static final String getUrlInvocazioneErogazione(AccordoServizioParteSpecifica asps, ErogazioniEnv env) throws Exception {
  2850.         
  2851.         
  2852.         final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2853.         final IDPortaApplicativa idPA = env.paCore.getIDPortaApplicativaAssociataDefault(idServizio);
  2854.         final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPA);
  2855.         final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  2856.         ConfigurazioneCore confCore = new ConfigurazioneCore(env.stationCore);
  2857.         
  2858.         Configurazione config = confCore.getConfigurazioneGenerale();
  2859.         
  2860.         ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = null;
  2861.         if(config!=null && config.getUrlInvocazione()!=null) {
  2862.             configurazioneUrlInvocazione = config.getUrlInvocazione();
  2863.         }
  2864.         
  2865.         List<String> tags = new ArrayList<>();
  2866.         if(aspc!=null && aspc.getGruppo()!=null && aspc.getGruppo().size()>0) {
  2867.             for (int i = 0; i < aspc.getGruppo().size(); i++) {
  2868.                 tags.add(aspc.getGruppo().get(i).getNome());
  2869.             }
  2870.         }
  2871.         
  2872.         String canaleApi = null;
  2873.         if(aspc!=null) {
  2874.             canaleApi = aspc.getCanale();
  2875.         }
  2876.         String canale = null;
  2877.         if(config!=null) {
  2878.             canale = CanaliUtils.getCanale(config.getGestioneCanali(), canaleApi, pa.getCanale());
  2879.         }
  2880.         
  2881.         org.openspcoop2.message.constants.ServiceBinding sbMessage = org.openspcoop2.message.constants.ServiceBinding.SOAP;
  2882.         if(aspc!=null) {
  2883.             sbMessage = (ServiceBinding.REST.equals(aspc.getServiceBinding())) ? org.openspcoop2.message.constants.ServiceBinding.REST : org.openspcoop2.message.constants.ServiceBinding.SOAP;
  2884.         }
  2885.         
  2886.         UrlInvocazioneAPI urlInvocazioneAPI = UrlInvocazioneAPI.getConfigurazioneUrlInvocazione(configurazioneUrlInvocazione, env.protocolFactory, RuoloContesto.PORTA_APPLICATIVA, 
  2887.                 sbMessage, 
  2888.                 pa.getNome(), idServizio.getSoggettoErogatore(),
  2889.                 tags, canale);      
  2890.         return urlInvocazioneAPI.getUrl();
  2891.         
  2892.     }
  2893.     
  2894.     public static final String getUrlInvocazioneFruizione(AccordoServizioParteSpecifica asps, IDSoggetto fruitore, ErogazioniEnv env) throws Exception {
  2895.         

  2897.         final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2898.         final IDPortaDelegata idPD = env.pdCore.getIDPortaDelegataAssociataDefault(idServizio, fruitore);
  2899.         final PortaDelegata pd = env.pdCore.getPortaDelegata(idPD);
  2900.         final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  2901.         
  2902.         ConfigurazioneCore confCore = new ConfigurazioneCore(env.stationCore);

  2904.         Configurazione config = confCore.getConfigurazioneGenerale();
  2905.         
  2906.         ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = null;
  2907.         if(config!=null && config.getUrlInvocazione()!=null) {
  2908.             configurazioneUrlInvocazione = config.getUrlInvocazione();
  2909.         }
  2910.         
  2911.         List<String> tags = new ArrayList<>();
  2912.         if(aspc!=null && aspc.getGruppo()!=null && aspc.getGruppo().size()>0) {
  2913.             for (int i = 0; i < aspc.getGruppo().size(); i++) {
  2914.                 tags.add(aspc.getGruppo().get(i).getNome());
  2915.             }
  2916.         }
  2917.         
  2918.         String canaleApi = null;
  2919.         if(aspc!=null) {
  2920.             canaleApi = aspc.getCanale();
  2921.         }
  2922.         String canale = null;
  2923.         if(config!=null) {
  2924.             canale = CanaliUtils.getCanale(config.getGestioneCanali(), canaleApi, pd.getCanale());
  2925.         }
  2926.         
  2927.         org.openspcoop2.message.constants.ServiceBinding sbMessage = org.openspcoop2.message.constants.ServiceBinding.SOAP;
  2928.         if(aspc!=null) {
  2929.             sbMessage = (ServiceBinding.REST.equals(aspc.getServiceBinding())) ? org.openspcoop2.message.constants.ServiceBinding.REST : org.openspcoop2.message.constants.ServiceBinding.SOAP;
  2930.         }
  2931.         
  2932.         UrlInvocazioneAPI urlInvocazioneAPI = UrlInvocazioneAPI.getConfigurazioneUrlInvocazione(configurazioneUrlInvocazione, env.protocolFactory, RuoloContesto.PORTA_DELEGATA, 
  2933.                 sbMessage, 
  2934.                 pd.getNome(), fruitore,
  2935.                 tags, canale);      
  2936.         return urlInvocazioneAPI.getUrl();
  2937.         
  2938.     }
  2939.     
  2940.     public static final void updateTracciamento(RegistrazioneDiagnosticiConfigurazione body, PortaApplicativa pa, ErogazioniEnv env) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  2941.         
  2942.         String tracciamentoStato = null;
  2943.         if(pa.getTracciamento()!=null && pa.getTracciamento().getStato()!=null && StatoFunzionalita.ABILITATO.equals(pa.getTracciamento().getStato())) {
  2944.             tracciamentoStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  2945.         }
  2946.         else {
  2947.             tracciamentoStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  2948.         }
  2949.         
  2950.         String statoDiagnostici = null;
  2951.         String severita = null;
  2952.         if(StatoDefaultRidefinitoEnum.RIDEFINITO.equals(body.getStato())) {
  2953.             statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  2954.             
  2955.             if(body.getSeverita()==null) {
  2956.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Severità non indicata."); 
  2957.             }
  2958.             switch (body.getSeverita()) {
  2959.             case ALL:
  2960.                 severita = org.openspcoop2.core.config.constants.Severita.ALL.getValue();
  2961.                 break;
  2962.             case DEBUG_HIGH:
  2963.                 severita = org.openspcoop2.core.config.constants.Severita.DEBUG_HIGH.getValue();
  2964.                 break;
  2965.             case DEBUG_MEDIUM:
  2966.                 severita = org.openspcoop2.core.config.constants.Severita.DEBUG_MEDIUM.getValue();
  2967.                 break;
  2968.             case DEBUG_LOW:
  2969.                 severita = org.openspcoop2.core.config.constants.Severita.DEBUG_LOW.getValue();
  2970.                 break;
  2971.             case INFO_PROTOCOL:
  2972.                 severita = org.openspcoop2.core.config.constants.Severita.INFO_PROTOCOL.getValue();
  2973.                 break;
  2974.             case INFO_INTEGRATION:
  2975.                 severita = org.openspcoop2.core.config.constants.Severita.INFO_INTEGRATION.getValue();
  2976.                 break;
  2977.             case ERROR_PROTOCOL:
  2978.                 severita = org.openspcoop2.core.config.constants.Severita.ERROR_PROTOCOL.getValue();
  2979.                 break;
  2980.             case ERROR_INTEGRATION:
  2981.                 severita = org.openspcoop2.core.config.constants.Severita.ERROR_INTEGRATION.getValue();
  2982.                 break;
  2983.             case FATAL:
  2984.                 severita = org.openspcoop2.core.config.constants.Severita.FATAL.getValue();
  2985.                 break;
  2986.             case OFF:
  2987.                 severita = org.openspcoop2.core.config.constants.Severita.OFF.getValue();
  2988.                 break;
  2989.             }
  2990.         }
  2991.         else {
  2992.             statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  2993.             
  2994.             if(body.getSeverita()!=null) {
  2995.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Severità non attesa."); 
  2996.             }
  2997.         }
  2998.         
  2999.         PorteApplicativeUtilities.initTracciamento(pa, env.paCore, null,
  3000.                 tracciamentoStato, statoDiagnostici, severita);
  3001.     }
  3002.     
  3003.     public static final void updateTracciamento(RegistrazioneDiagnosticiConfigurazione body, PortaDelegata pd, ErogazioniEnv env) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  3004.         
  3005.         String tracciamentoStato = null;
  3006.         if(pd.getTracciamento()!=null && pd.getTracciamento().getStato()!=null && StatoFunzionalita.ABILITATO.equals(pd.getTracciamento().getStato())) {
  3007.             tracciamentoStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  3008.         }
  3009.         else {
  3010.             tracciamentoStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3011.         }
  3012.         
  3013.         String statoDiagnostici = null;
  3014.         String severita = null;
  3015.         if(StatoDefaultRidefinitoEnum.RIDEFINITO.equals(body.getStato())) {
  3016.             statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  3017.             
  3018.             if(body.getSeverita()==null) {
  3019.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Severità non indicata."); 
  3020.             }
  3021.             switch (body.getSeverita()) {
  3022.             case ALL:
  3023.                 severita = org.openspcoop2.core.config.constants.Severita.ALL.getValue();
  3024.                 break;
  3025.             case DEBUG_HIGH:
  3026.                 severita = org.openspcoop2.core.config.constants.Severita.DEBUG_HIGH.getValue();
  3027.                 break;
  3028.             case DEBUG_MEDIUM:
  3029.                 severita = org.openspcoop2.core.config.constants.Severita.DEBUG_MEDIUM.getValue();
  3030.                 break;
  3031.             case DEBUG_LOW:
  3032.                 severita = org.openspcoop2.core.config.constants.Severita.DEBUG_LOW.getValue();
  3033.                 break;
  3034.             case INFO_PROTOCOL:
  3035.                 severita = org.openspcoop2.core.config.constants.Severita.INFO_PROTOCOL.getValue();
  3036.                 break;
  3037.             case INFO_INTEGRATION:
  3038.                 severita = org.openspcoop2.core.config.constants.Severita.INFO_INTEGRATION.getValue();
  3039.                 break;
  3040.             case ERROR_PROTOCOL:
  3041.                 severita = org.openspcoop2.core.config.constants.Severita.ERROR_PROTOCOL.getValue();
  3042.                 break;
  3043.             case ERROR_INTEGRATION:
  3044.                 severita = org.openspcoop2.core.config.constants.Severita.ERROR_INTEGRATION.getValue();
  3045.                 break;
  3046.             case FATAL:
  3047.                 severita = org.openspcoop2.core.config.constants.Severita.FATAL.getValue();
  3048.                 break;
  3049.             case OFF:
  3050.                 severita = org.openspcoop2.core.config.constants.Severita.OFF.getValue();
  3051.                 break;
  3052.             }
  3053.         }
  3054.         else {
  3055.             statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3056.             
  3057.             if(body.getSeverita()!=null) {
  3058.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Severità non attesa."); 
  3059.             }
  3060.         }
  3061.         
  3062.         PorteDelegateUtilities.initTracciamento(pd, env.pdCore, null,
  3063.                 tracciamentoStato, statoDiagnostici, severita);
  3064.     }
  3065.     
  3066.     public static final void updateTracciamento(RegistrazioneTransazioniConfigurazione body, 
  3067.             Object porta, ErogazioniEnv environment) throws DriverConfigurazioneNotFound, DriverConfigurazioneException, ProtocolException {
  3068.         
  3069.         PortaApplicativa portaApplicativa = null;
  3070.         PortaDelegata portaDelegata = null;
  3071.         boolean applicativa = false;
  3072.         if(porta instanceof PortaApplicativa) {
  3073.             portaApplicativa = (PortaApplicativa) porta;
  3074.             applicativa = true;
  3075.         }
  3076.         else if(porta instanceof PortaDelegata) {
  3077.             portaDelegata = (PortaDelegata) porta;
  3078.         }
  3079.         else {
  3080.             throw new ProtocolException("Oggetto '"+porta.getClass().getName()+"' non supportato");
  3081.         }
  3082.         
  3083.         String statoDiagnostici = null;
  3084.         if(applicativa) {
  3085.             if(portaApplicativa.getTracciamento()!=null && portaApplicativa.getTracciamento().getSeverita()!=null) {
  3086.                 statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  3087.             }
  3088.             else {
  3089.                 statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3090.             }
  3091.         }
  3092.         else {
  3093.             if(portaDelegata.getTracciamento()!=null && portaDelegata.getTracciamento().getSeverita()!=null) {
  3094.                 statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  3095.             }
  3096.             else {
  3097.                 statoDiagnostici = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3098.             }
  3099.         }
  3100.     
  3101.         String severita = null;
  3102.         if(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO.equals(statoDiagnostici)) {
  3103.             // prendo quella di default
  3104.             if(applicativa && portaApplicativa.getTracciamento()!=null && portaApplicativa.getTracciamento().getSeverita()!=null) {
  3105.                 severita = portaApplicativa.getTracciamento().getSeverita().getValue();
  3106.             }
  3107.             else if(portaDelegata.getTracciamento()!=null && portaDelegata.getTracciamento().getSeverita()!=null) {
  3108.                 severita = portaDelegata.getTracciamento().getSeverita().getValue();    
  3109.             }
  3110.             
  3111.             if(severita==null) {
  3112.                 Configurazione config = environment.configCore.getConfigurazioneGenerale();
  3113.                 severita = config.getMessaggiDiagnostici()!=null && config.getMessaggiDiagnostici().getSeverita()!=null ? 
  3114.                         config.getMessaggiDiagnostici().getSeverita().getValue() : 
  3115.                         null;
  3116.             }
  3117.         }
  3118.         
  3119.         String tracciamentoStato = null;
  3120.         boolean ridefinito = false;
  3121.         if(body.getStato()!=null && StatoDefaultRidefinitoEnum.RIDEFINITO.equals(body.getStato())) {
  3122.             tracciamentoStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  3123.             ridefinito = true;
  3124.         }
  3125.         else {
  3126.             tracciamentoStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3127.         }
  3128.         
  3129.         if(applicativa) {
  3130.             PorteApplicativeUtilities.initTracciamento(portaApplicativa, environment.paCore, null,
  3131.                     tracciamentoStato, statoDiagnostici, severita);
  3132.         }
  3133.         else {
  3134.             PorteDelegateUtilities.initTracciamento(portaDelegata, environment.pdCore, null,
  3135.                     tracciamentoStato, statoDiagnostici, severita);
  3136.         }
  3137.         
  3138.         String dbStato = null;
  3139.         String dbStatoReqIn = null;
  3140.         String dbStatoReqOut = null;
  3141.         String dbStatoResOut = null;
  3142.         String dbStatoResOutComplete = null;
  3143.         boolean dbFiltroEsiti = false;
  3144.         if(body.getDatabase()!=null) {
  3145.             if(!ridefinito) {
  3146.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Stato tracciamento su db consentito solo con stato ridefinito."); 
  3147.             }
  3148.             if(body.getDatabase().getStato()==null) {
  3149.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Stato tracciamento su db non indicato."); 
  3150.             }
  3151.             String prefixDB = "Stato tracciamento su db '"+body.getDatabase().getStato()+"'";
  3152.             
  3153.             boolean personalizzato = false;
  3154.             switch (body.getDatabase().getStato()) {
  3155.             case ABILITATO:
  3156.                 dbStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.ABILITATO.getValue();
  3157.                 break;
  3158.             case DISABILITATO:
  3159.                 dbStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.DISABILITATO.getValue();
  3160.                 break;
  3161.             case CONFIGURAZIONEESTERNA:
  3162.                 /**dbStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.CONFIGURAZIONE_ESTERNA.getValue();*/
  3163.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" non valido."); 
  3164.             case PERSONALIZZATO:
  3165.                 dbStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue();
  3166.                 personalizzato = true;
  3167.                 break;
  3168.             }
  3169.             if(body.getDatabase().getFiltroEsiti()!=null) {
  3170.                 dbFiltroEsiti = TracciamentoTransazioniStatoFase.ABILITATO.equals(body.getDatabase().getFiltroEsiti());
  3171.             }
  3172.             if(body.getDatabase().getFasi()!=null) {
  3173.                 if(personalizzato) {
  3174.                     if(body.getDatabase().getFasi().getRichiestaIngresso()!=null) {
  3175.                         switch (body.getDatabase().getFasi().getRichiestaIngresso()) {
  3176.                         case BLOCCANTE:
  3177.                             dbStatoReqIn = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.ABILITATO.getValue();
  3178.                             break;
  3179.                         case NON_BLOCCANTE:
  3180.                             dbStatoReqIn = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue();
  3181.                             break;
  3182.                         case DISABILITATO:
  3183.                             dbStatoReqIn = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.DISABILITATO.getValue();
  3184.                             break;
  3185.                         }
  3186.                     }
  3187.                     else {
  3188.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" richiede la definizione delle fasi; fase 'richiesta ingresso' non definita"); 
  3189.                     }
  3190.                     
  3191.                     if(body.getDatabase().getFasi().getRichiestaUscita()!=null) {
  3192.                         switch (body.getDatabase().getFasi().getRichiestaUscita()) {
  3193.                         case BLOCCANTE:
  3194.                             dbStatoReqOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.ABILITATO.getValue();
  3195.                             break;
  3196.                         case NON_BLOCCANTE:
  3197.                             dbStatoReqOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue();
  3198.                             break;
  3199.                         case DISABILITATO:
  3200.                             dbStatoReqOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.DISABILITATO.getValue();
  3201.                             break;
  3202.                         }
  3203.                     }
  3204.                     else {
  3205.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" richiede la definizione delle fasi; fase 'richiesta uscita' non definita"); 
  3206.                     }
  3207.                     
  3208.                     if(body.getDatabase().getFasi().getRispostaUscita()!=null) {
  3209.                         switch (body.getDatabase().getFasi().getRispostaUscita()) {
  3210.                         case BLOCCANTE:
  3211.                             dbStatoResOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.ABILITATO.getValue();
  3212.                             break;
  3213.                         case NON_BLOCCANTE:
  3214.                             dbStatoResOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue();
  3215.                             break;
  3216.                         case DISABILITATO:
  3217.                             dbStatoResOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.DISABILITATO.getValue();
  3218.                             break;
  3219.                         }
  3220.                     }
  3221.                     else {
  3222.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" richiede la definizione delle fasi; fase 'risposta uscita' non definita"); 
  3223.                     }
  3224.                     
  3225.                     if(body.getDatabase().getFasi().getRispostaConsegnata()!=null) {
  3226.                         if(TracciamentoTransazioniStatoFase.ABILITATO.equals(body.getDatabase().getFasi().getRispostaConsegnata())) {
  3227.                             dbStatoResOutComplete = org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.getValue();
  3228.                         }else {
  3229.                             dbStatoResOutComplete = org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO.getValue();
  3230.                         }
  3231.                     }
  3232.                     else {
  3233.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" richiede la definizione delle fasi; fase 'risposta consegnata' non definita"); 
  3234.                     }
  3235.                 }
  3236.                 else {
  3237.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" non prevede la definizione delle fasi."); 
  3238.                 }
  3239.             }
  3240.             else {
  3241.                 if(personalizzato) {
  3242.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixDB+" richiede la definizione delle fasi.");
  3243.                 }
  3244.             }
  3245.         }
  3246.         
  3247.         String fsStato = null;
  3248.         String fsStatoReqIn = null;
  3249.         String fsStatoReqOut = null;
  3250.         String fsStatoResOut = null;
  3251.         String fsStatoResOutComplete = null;
  3252.         boolean fsFiltroEsiti = false;
  3253.         
  3254.         String fileTraceStato = null;
  3255.         String fileTraceConfigFile = null;
  3256.         String fileTraceClient = null;
  3257.         String fileTraceClientHdr = null;
  3258.         String fileTraceClientBody = null;
  3259.         String fileTraceServer = null;
  3260.         String fileTraceServerHdr = null;
  3261.         String fileTraceServerBody = null;
  3262.         
  3263.         if(body.getFiletrace()!=null) {
  3264.             
  3265.             if(!ridefinito) {
  3266.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Stato tracciamento su filetrace consentito solo con stato ridefinito."); 
  3267.             }
  3268.             
  3269.             if(body.getFiletrace().getStato()==null) {
  3270.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Stato tracciamento su filetrace non indicato."); 
  3271.             }
  3272.             String prefixFS =  "Stato tracciamento su filetrace '"+body.getFiletrace().getStato()+"'";
  3273.             
  3274.             boolean abilitataConf = false;
  3275.             boolean personalizzato = false;
  3276.             switch (body.getFiletrace().getStato()) {
  3277.             case ABILITATO:
  3278.                 fsStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.ABILITATO.getValue();
  3279.                 abilitataConf = true;
  3280.                 break;
  3281.             case DISABILITATO:
  3282.                 fsStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.DISABILITATO.getValue();
  3283.                 break;
  3284.             case CONFIGURAZIONEESTERNA:
  3285.                 fsStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.CONFIGURAZIONE_ESTERNA.getValue();
  3286.                 break;
  3287.             case PERSONALIZZATO:
  3288.                 fsStato = org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue();
  3289.                 personalizzato = true;
  3290.                 abilitataConf = true;
  3291.                 break;
  3292.             }
  3293.             if(body.getFiletrace().getFiltroEsiti()!=null) {
  3294.                 fsFiltroEsiti = TracciamentoTransazioniStatoFase.ABILITATO.equals(body.getFiletrace().getFiltroEsiti());
  3295.             }
  3296.             if(body.getFiletrace().getFasi()!=null) {
  3297.                 if(personalizzato) {
  3298.                     if(body.getFiletrace().getFasi().getRichiestaIngresso()!=null) {
  3299.                         switch (body.getFiletrace().getFasi().getRichiestaIngresso()) {
  3300.                         case BLOCCANTE:
  3301.                             fsStatoReqIn = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.ABILITATO.getValue();
  3302.                             break;
  3303.                         case NON_BLOCCANTE:
  3304.                             fsStatoReqIn = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue();
  3305.                             break;
  3306.                         case DISABILITATO:
  3307.                             fsStatoReqIn = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.DISABILITATO.getValue();
  3308.                             break;
  3309.                         }
  3310.                     }
  3311.                     else {
  3312.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" richiede la definizione delle fasi; fase 'richiesta ingresso' non definita"); 
  3313.                     }
  3314.                     
  3315.                     if(body.getFiletrace().getFasi().getRichiestaUscita()!=null) {
  3316.                         switch (body.getFiletrace().getFasi().getRichiestaUscita()) {
  3317.                         case BLOCCANTE:
  3318.                             fsStatoReqOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.ABILITATO.getValue();
  3319.                             break;
  3320.                         case NON_BLOCCANTE:
  3321.                             fsStatoReqOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue();
  3322.                             break;
  3323.                         case DISABILITATO:
  3324.                             fsStatoReqOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.DISABILITATO.getValue();
  3325.                             break;
  3326.                         }
  3327.                     }
  3328.                     else {
  3329.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" richiede la definizione delle fasi; fase 'richiesta uscita' non definita"); 
  3330.                     }
  3331.                     
  3332.                     if(body.getFiletrace().getFasi().getRispostaUscita()!=null) {
  3333.                         switch (body.getFiletrace().getFasi().getRispostaUscita()) {
  3334.                         case BLOCCANTE:
  3335.                             fsStatoResOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.ABILITATO.getValue();
  3336.                             break;
  3337.                         case NON_BLOCCANTE:
  3338.                             fsStatoResOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue();
  3339.                             break;
  3340.                         case DISABILITATO:
  3341.                             fsStatoResOut = org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante.DISABILITATO.getValue();
  3342.                             break;
  3343.                         }
  3344.                     }
  3345.                     else {
  3346.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" richiede la definizione delle fasi; fase 'risposta uscita' non definita"); 
  3347.                     }
  3348.                     
  3349.                     if(body.getFiletrace().getFasi().getRispostaConsegnata()!=null) {
  3350.                         if(TracciamentoTransazioniStatoFase.ABILITATO.equals(body.getFiletrace().getFasi().getRispostaConsegnata())) {
  3351.                             fsStatoResOutComplete = org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.getValue();
  3352.                         }else {
  3353.                             fsStatoResOutComplete = org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO.getValue();
  3354.                         }
  3355.                     }
  3356.                     else {
  3357.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" richiede la definizione delle fasi; fase 'risposta consegnata' non definita"); 
  3358.                     }
  3359.                 }
  3360.                 else {
  3361.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" non prevede la definizione delle fasi."); 
  3362.                 }
  3363.             }
  3364.             else {
  3365.                 if(personalizzato) {
  3366.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" richiede la definizione delle fasi.");
  3367.                 }
  3368.             }
  3369.             
  3370.             if(abilitataConf) {
  3371.                 if(body.getFiletrace().getConfigPath()!=null || 
  3372.                         body.getFiletrace().getDumpClient()!=null ||
  3373.                         body.getFiletrace().getDumpServer()!=null) {
  3374.                     fileTraceStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  3375.                     
  3376.                     fileTraceConfigFile = body.getFiletrace().getConfigPath();
  3377.                     
  3378.                     if(body.getFiletrace().getDumpClient()!=null) {
  3379.                         fileTraceClient = ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO;
  3380.                         
  3381.                         if(body.getFiletrace().getDumpClient().isHeaders()!=null && body.getFiletrace().getDumpClient().isHeaders().booleanValue()) {
  3382.                             fileTraceClientHdr = ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO;
  3383.                         }
  3384.                         else {
  3385.                             fileTraceClientHdr = ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO;
  3386.                         }
  3387.                         
  3388.                         if(body.getFiletrace().getDumpClient().isPayload()!=null && body.getFiletrace().getDumpClient().isPayload().booleanValue()) {
  3389.                             fileTraceClientBody = ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO;
  3390.                         }
  3391.                         else {
  3392.                             fileTraceClientBody = ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO;
  3393.                         }
  3394.                     }
  3395.                     else {
  3396.                         fileTraceClient = ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO;
  3397.                     }
  3398.                     
  3399.                     if(body.getFiletrace().getDumpServer()!=null) {
  3400.                         fileTraceServer = ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO;
  3401.                         
  3402.                         if(body.getFiletrace().getDumpServer().isHeaders()!=null && body.getFiletrace().getDumpServer().isHeaders().booleanValue()) {
  3403.                             fileTraceServerHdr = ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO;
  3404.                         }
  3405.                         else {
  3406.                             fileTraceServerHdr = ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO;
  3407.                         }
  3408.                         
  3409.                         if(body.getFiletrace().getDumpServer().isPayload()!=null && body.getFiletrace().getDumpServer().isPayload().booleanValue()) {
  3410.                             fileTraceServerBody = ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO;
  3411.                         }
  3412.                         else {
  3413.                             fileTraceServerBody = ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO;
  3414.                         }
  3415.                     }
  3416.                     else {
  3417.                         fileTraceServer = ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO;
  3418.                     }
  3419.                 }
  3420.                 else {
  3421.                     fileTraceStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3422.                 }
  3423.             }
  3424.             else {
  3425.                 if(body.getFiletrace().getConfigPath()!=null) {
  3426.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" non consente la definizione del path della configurazione"); 
  3427.                 }
  3428.                 if(body.getFiletrace().getDumpClient()!=null) {
  3429.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" non consente la definizione del buffer dei messaggi scambiati con il client"); 
  3430.                 }
  3431.                 if(body.getFiletrace().getDumpServer()!=null) {
  3432.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(prefixFS+" non consente la definizione del buffer dei messaggi scambiati con il server"); 
  3433.                 }
  3434.                 fileTraceStato = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3435.             }
  3436.             
  3437.         }
  3438.         
  3439.         
  3440.         String nuovaConfigurazioneEsiti = null;
  3441.         if(body.getFiltro()!=null && body.getFiltro().getEsiti()!=null && !body.getFiltro().getEsiti().isEmpty()) {
  3442.             
  3443.             if(!ridefinito) {
  3444.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Filtro esiti consentito solo con stato ridefinito."); 
  3445.             }
  3446.             
  3447.             Logger log = LoggerWrapperFactory.getLogger(ErogazioniApiHelper.class);
  3448.             EsitiProperties esitiProperties = EsitiProperties.getInstance(log, environment.protocolFactory);
  3449.             List<Integer> esiti = esitiProperties.getEsitiCode();
  3450.             int codeErroreProtocollo = esitiProperties.convertNameToCode(EsitoTransazioneName.ERRORE_PROTOCOLLO.name());
  3451.             int codeFaultPdd = esitiProperties.convertNameToCode(EsitoTransazioneName.ERRORE_SERVER.name());
  3452.             esiti.add(codeErroreProtocollo);
  3453.             esiti.add(codeFaultPdd);
  3454.             StringBuilder sb = new StringBuilder();
  3455.             for (Integer esito : body.getFiltro().getEsiti()) {
  3456.                 if(sb.length()>0) {
  3457.                     sb.append(",");
  3458.                 }
  3459.                 sb.append(esito.intValue());
  3460.                 if(!existsEsito(esito, esiti )) {
  3461.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'esito '"+esito+"' indicato nel filtro non è supportato");   
  3462.                 }
  3463.             }
  3464.             nuovaConfigurazioneEsiti = sb.toString();
  3465.         }
  3466.         
  3467.         
  3468.         String transazioniTempiElaborazione = null;
  3469.         String transazioniToken = null;
  3470.         if(body.getInformazioni()!=null) {
  3471.             
  3472.             if(!ridefinito) {
  3473.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Definizione delle informazioni sulle transazioni consentita solo con stato ridefinito."); 
  3474.             }
  3475.             
  3476.             if(body.getInformazioni().getTempiElaborazione()!=null) {
  3477.                 if(TracciamentoTransazioniStatoFase.ABILITATO.equals(body.getInformazioni().getTempiElaborazione())) {
  3478.                     transazioniTempiElaborazione = StatoFunzionalita.ABILITATO.getValue();
  3479.                 }
  3480.                 else {
  3481.                     transazioniTempiElaborazione = StatoFunzionalita.DISABILITATO.getValue();
  3482.                 }
  3483.             }
  3484.             else {
  3485.                 transazioniTempiElaborazione = StatoFunzionalita.DISABILITATO.getValue();
  3486.             }
  3487.             
  3488.             if(body.getInformazioni().getToken()!=null) {
  3489.                 if(TracciamentoTransazioniStatoFase.ABILITATO.equals(body.getInformazioni().getToken())) {
  3490.                     transazioniToken = StatoFunzionalita.ABILITATO.getValue();
  3491.                 }
  3492.                 else {
  3493.                     transazioniToken = StatoFunzionalita.DISABILITATO.getValue();
  3494.                 }
  3495.             }
  3496.             else {
  3497.                 transazioniToken = StatoFunzionalita.DISABILITATO.getValue();
  3498.             }
  3499.         }               
  3500.         

  3502.         if(applicativa) {
  3503.             PorteApplicativeUtilities.setTracciamentoTransazioni(portaApplicativa, environment.paCore,
  3504.                     dbStato,
  3505.                     dbStatoReqIn, dbStatoReqOut, dbStatoResOut, dbStatoResOutComplete,
  3506.                     dbFiltroEsiti,
  3507.                     fsStato,
  3508.                     fsStatoReqIn, fsStatoReqOut, fsStatoResOut, fsStatoResOutComplete,
  3509.                     fsFiltroEsiti,
  3510.                     nuovaConfigurazioneEsiti,
  3511.                     transazioniTempiElaborazione, transazioniToken,
  3512.                     fileTraceStato, fileTraceConfigFile,
  3513.                     fileTraceClient, fileTraceClientHdr, fileTraceClientBody,
  3514.                     fileTraceServer, fileTraceServerHdr, fileTraceServerBody);
  3515.         }
  3516.         else {
  3517.             PorteDelegateUtilities.setTracciamentoTransazioni(portaDelegata, environment.pdCore,
  3518.                     dbStato,
  3519.                     dbStatoReqIn, dbStatoReqOut, dbStatoResOut, dbStatoResOutComplete,
  3520.                     dbFiltroEsiti,
  3521.                     fsStato,
  3522.                     fsStatoReqIn, fsStatoReqOut, fsStatoResOut, fsStatoResOutComplete,
  3523.                     fsFiltroEsiti,
  3524.                     nuovaConfigurazioneEsiti,
  3525.                     transazioniTempiElaborazione, transazioniToken,
  3526.                     fileTraceStato, fileTraceConfigFile,
  3527.                     fileTraceClient, fileTraceClientHdr, fileTraceClientBody,
  3528.                     fileTraceServer, fileTraceServerHdr, fileTraceServerBody);
  3529.         }
  3530.     }
  3531.     private static boolean existsEsito(Integer esito, List<Integer> esiti ) {
  3532.         if(esiti!=null && esito!=null) {
  3533.             for (Integer e : esiti) {
  3534.                 if(e.intValue() == esito.intValue()) {
  3535.                     return true;
  3536.                 }
  3537.             }
  3538.         }
  3539.         return false;
  3540.     }
  3541.     
  3542.     public static final DumpConfigurazione buildDumpConfigurazione(RegistrazioneMessaggi dumpConf, boolean isErogazione, ErogazioniEnv env) throws Exception {
  3543.         final RegistrazioneMessaggiConfigurazione richiesta = dumpConf.getRichiesta();
  3544.         final RegistrazioneMessaggiConfigurazione risposta = dumpConf.getRisposta();

  3546.         final String statoDump = dumpConf.getStato().toString(); 
  3547.         final String statoDumpRichiesta             = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.isAbilitato() )).toString();
  3548.         final String statoDumpRisposta              = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.isAbilitato() )).toString();
  3549.         
  3550.         final String dumpRichiestaIngressoHeader    = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getIngresso().isHeaders() )).toString();
  3551.         final String dumpRichiestaIngressoPayload   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getIngresso().isPayload() )).toString();
  3552.         String dumpRichiestaIngressoPayloadParsing = Helper.boolToStatoFunzionalitaConf(false).toString();
  3553.         String dumpRichiestaIngressoBody        = Helper.boolToStatoFunzionalitaConf(false).toString();
  3554.         String dumpRichiestaIngressoAttachments =  Helper.boolToStatoFunzionalitaConf(false).toString();
  3555.         if(richiesta!=null && richiesta.getIngresso()!=null && 
  3556.                 richiesta.getIngresso().isPayload()!=null && richiesta.getIngresso().isPayload()) {
  3557.             dumpRichiestaIngressoPayloadParsing = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getIngresso().isPayloadParsing() )).toString();
  3558.             if(richiesta.getIngresso().isPayloadParsing()!=null && richiesta.getIngresso().isPayloadParsing()) {
  3559.                 dumpRichiestaIngressoBody   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getIngresso().isBody() )).toString();
  3560.                 dumpRichiestaIngressoAttachments   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getIngresso().isAttachments() )).toString();
  3561.             }
  3562.         }
  3563.         
  3564.         final String dumpRichiestaUscitaHeader  = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getUscita().isHeaders() )).toString();
  3565.         final String dumpRichiestaUscitaPayload   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getUscita().isPayload() )).toString();
  3566.         String dumpRichiestaUscitaPayloadParsing = Helper.boolToStatoFunzionalitaConf(false).toString();
  3567.         String dumpRichiestaUscitaBody      = Helper.boolToStatoFunzionalitaConf(false).toString();
  3568.         String dumpRichiestaUscitaAttachments =  Helper.boolToStatoFunzionalitaConf(false).toString();
  3569.         if(richiesta!=null && richiesta.getUscita()!=null && 
  3570.                 richiesta.getUscita().isPayload()!=null && richiesta.getUscita().isPayload()) {
  3571.             dumpRichiestaUscitaPayloadParsing = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getUscita().isPayloadParsing() )).toString();
  3572.             if(richiesta.getUscita().isPayloadParsing()!=null && richiesta.getUscita().isPayloadParsing()) {
  3573.                 dumpRichiestaUscitaBody   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getUscita().isBody() )).toString();
  3574.                 dumpRichiestaUscitaAttachments   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> richiesta.getUscita().isAttachments() )).toString();
  3575.             }
  3576.         }
  3577.         
  3578.         final String dumpRispostaIngressoHeader = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getIngresso().isHeaders() )).toString();
  3579.         final String dumpRispostaIngressoPayload   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getIngresso().isPayload() )).toString();
  3580.         String dumpRispostaIngressoPayloadParsing = Helper.boolToStatoFunzionalitaConf(false).toString();
  3581.         String dumpRispostaIngressoBody         = Helper.boolToStatoFunzionalitaConf(false).toString();
  3582.         String dumpRispostaIngressoAttachments =  Helper.boolToStatoFunzionalitaConf(false).toString();
  3583.         if(risposta!=null && risposta.getIngresso()!=null && 
  3584.                 risposta.getIngresso().isPayload()!=null && risposta.getIngresso().isPayload()) {
  3585.             dumpRispostaIngressoPayloadParsing = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getIngresso().isPayloadParsing() )).toString();
  3586.             if(risposta.getIngresso().isPayloadParsing()!=null && risposta.getIngresso().isPayloadParsing()) {
  3587.                 dumpRispostaIngressoBody   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getIngresso().isBody() )).toString();
  3588.                 dumpRispostaIngressoAttachments   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getIngresso().isAttachments() )).toString();
  3589.             }
  3590.         }
  3591.         
  3592.         final String dumpRispostaUscitaHeader   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getUscita().isHeaders() )).toString();
  3593.         final String dumpRispostaUscitaPayload   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getUscita().isPayload() )).toString();
  3594.         String dumpRispostaUscitaPayloadParsing = Helper.boolToStatoFunzionalitaConf(false).toString();
  3595.         String dumpRispostaUscitaBody       = Helper.boolToStatoFunzionalitaConf(false).toString();
  3596.         String dumpRispostaUscitaAttachments =  Helper.boolToStatoFunzionalitaConf(false).toString();
  3597.         if(risposta!=null && risposta.getUscita()!=null && 
  3598.                 risposta.getUscita().isPayload()!=null && risposta.getUscita().isPayload()) {
  3599.             dumpRispostaUscitaPayloadParsing = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getUscita().isPayloadParsing() )).toString();
  3600.             if(risposta.getUscita().isPayloadParsing()!=null && risposta.getUscita().isPayloadParsing()) {
  3601.                 dumpRispostaUscitaBody   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getUscita().isBody() )).toString();
  3602.                 dumpRispostaUscitaAttachments   = Helper.boolToStatoFunzionalitaConf( evalnull( () -> risposta.getUscita().isAttachments() )).toString();
  3603.             }
  3604.         }
  3605.         
  3606.         DumpConfigurazione ret = new DumpConfigurazione();
  3607.         
  3608.         // Caso porta applicativa
  3609.         if (isErogazione) {
  3610.             if (!env.paHelper.checkDataConfigurazioneDump(TipoOperazione.OTHER,
  3611.                     true,   // showStato
  3612.                     statoDump,
  3613.                     false,  // showRealtime, 
  3614.                     StatoFunzionalita.ABILITATO.getValue(), 
  3615.                     statoDumpRichiesta, 
  3616.                     statoDumpRisposta, 
  3617.                     dumpRichiestaIngressoHeader, dumpRichiestaIngressoPayload, dumpRichiestaIngressoPayloadParsing, dumpRichiestaIngressoBody, dumpRichiestaIngressoAttachments, 
  3618.                     dumpRichiestaUscitaHeader, dumpRichiestaUscitaPayload, dumpRichiestaUscitaPayloadParsing, dumpRichiestaUscitaBody, dumpRichiestaUscitaAttachments, 
  3619.                     dumpRispostaIngressoHeader, dumpRispostaIngressoPayload, dumpRispostaIngressoPayloadParsing, dumpRispostaIngressoBody, dumpRispostaIngressoAttachments,
  3620.                     dumpRispostaUscitaHeader, dumpRispostaUscitaPayload, dumpRispostaUscitaPayloadParsing, dumpRispostaUscitaBody, dumpRispostaUscitaAttachments
  3621.                 )) {
  3622.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3623.             }
  3624.             
  3625.             ret = env.paHelper.getConfigurazioneDump(TipoOperazione.OTHER,
  3626.                     true,   // showStato
  3627.                     statoDump,
  3628.                     false,  // showRealtime, 
  3629.                     StatoFunzionalita.ABILITATO.getValue(),         // realtime, Come da debug
  3630.                     statoDumpRichiesta, 
  3631.                     statoDumpRisposta, 
  3632.                     dumpRichiestaIngressoHeader, dumpRichiestaIngressoPayload, dumpRichiestaIngressoPayloadParsing, dumpRichiestaIngressoBody, dumpRichiestaIngressoAttachments, 
  3633.                     dumpRichiestaUscitaHeader, dumpRichiestaUscitaPayload, dumpRichiestaUscitaPayloadParsing, dumpRichiestaUscitaBody, dumpRichiestaUscitaAttachments, 
  3634.                     dumpRispostaIngressoHeader, dumpRispostaIngressoPayload, dumpRispostaIngressoPayloadParsing, dumpRispostaIngressoBody, dumpRispostaIngressoAttachments,
  3635.                     dumpRispostaUscitaHeader, dumpRispostaUscitaPayload, dumpRispostaUscitaPayloadParsing, dumpRispostaUscitaBody, dumpRispostaUscitaAttachments
  3636.                 );
  3637.         } 
  3638.         else {  
  3639.             
  3640.             // Caso porta delegata
  3641.             
  3642.             if (!env.pdHelper.checkDataConfigurazioneDump(TipoOperazione.OTHER,
  3643.                     true,   // showStato
  3644.                     statoDump,
  3645.                     false,  // showRealtime, 
  3646.                     StatoFunzionalita.ABILITATO.getValue(), // realtime 
  3647.                     statoDumpRichiesta, 
  3648.                     statoDumpRisposta, 
  3649.                     dumpRichiestaIngressoHeader, dumpRichiestaIngressoPayload, dumpRichiestaIngressoPayloadParsing, dumpRichiestaIngressoBody, dumpRichiestaIngressoAttachments, 
  3650.                     dumpRichiestaUscitaHeader, dumpRichiestaUscitaPayload, dumpRichiestaUscitaPayloadParsing, dumpRichiestaUscitaBody, dumpRichiestaUscitaAttachments, 
  3651.                     dumpRispostaIngressoHeader, dumpRispostaIngressoPayload, dumpRispostaIngressoPayloadParsing, dumpRispostaIngressoBody, dumpRispostaIngressoAttachments,
  3652.                     dumpRispostaUscitaHeader, dumpRispostaUscitaPayload, dumpRispostaUscitaPayloadParsing, dumpRispostaUscitaBody, dumpRispostaUscitaAttachments
  3653.                 )) {
  3654.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3655.             }
  3656.             
  3657.             ret = env.pdHelper.getConfigurazioneDump(TipoOperazione.OTHER,
  3658.                     true,   // showStato
  3659.                     statoDump,
  3660.                     false,  // showRealtime, 
  3661.                     StatoFunzionalita.ABILITATO.getValue(), // realtime, Come da debug 
  3662.                     statoDumpRichiesta, 
  3663.                     statoDumpRisposta, 
  3664.                     dumpRichiestaIngressoHeader, dumpRichiestaIngressoPayload, dumpRichiestaIngressoPayloadParsing, dumpRichiestaIngressoBody, dumpRichiestaIngressoAttachments, 
  3665.                     dumpRichiestaUscitaHeader, dumpRichiestaUscitaPayload, dumpRichiestaUscitaPayloadParsing, dumpRichiestaUscitaBody, dumpRichiestaUscitaAttachments, 
  3666.                     dumpRispostaIngressoHeader, dumpRispostaIngressoPayload, dumpRispostaIngressoPayloadParsing, dumpRispostaIngressoBody, dumpRispostaIngressoAttachments,
  3667.                     dumpRispostaUscitaHeader, dumpRispostaUscitaPayload, dumpRispostaUscitaPayloadParsing, dumpRispostaUscitaBody, dumpRispostaUscitaAttachments
  3668.                 );
  3669.         }
  3670.         
  3671.         return ret;
  3672.         
  3673.     }
  3674.     
  3675.     
  3676.     public static final List<MappingErogazionePortaApplicativa> getMappingGruppiPA(String nomeGruppo, IdServizio idAsps,  
  3677.             AccordiServizioParteSpecificaCore apsCore ) throws Exception {
  3678.         
  3679.         return apsCore.mappingServiziPorteAppList(idAsps,idAsps.getId(), null).stream()
  3680.             .filter( m -> m.getDescrizione().equals(nomeGruppo) )
  3681.             .collect(Collectors.toList());
  3682.         
  3683.     }
  3684.     
  3685.     
  3686.     public static final List<MappingFruizionePortaDelegata> getMappingGruppiPD(
  3687.             String nomeGruppo,
  3688.             IDSoggetto idFruitore,
  3689.             IdServizio idAsps,  
  3690.             AccordiServizioParteSpecificaCore apsCore ) throws Exception {
  3691.         
  3692.         return apsCore.serviziFruitoriMappingList(idFruitore, idAsps, null).stream()
  3693.             .filter( m -> m.getDescrizione().equals(nomeGruppo))
  3694.             .collect(Collectors.toList());
  3695.         
  3696.     }
  3697.     
  3698.     public static final IDPortaApplicativa getIDGruppoPA(String nome, IdServizio idAsps, AccordiServizioParteSpecificaCore apsCore) throws Exception {
  3699.         
  3700.         return getMappingGruppiPA(nome, idAsps, apsCore).stream()
  3701.                 .map( m -> m.getIdPortaApplicativa() )
  3702.                 .findFirst()
  3703.                 .orElse(null);
  3704.         
  3705.     }
  3706.     
  3707.     
  3708.     public static final IDPortaApplicativa getIDGruppoPADefault(IdServizio idAsps, AccordiServizioParteSpecificaCore apsCore) throws Exception {
  3709.         return AccordiServizioParteSpecificaUtilities.getDefaultMappingPA(apsCore.mappingServiziPorteAppList(idAsps,idAsps.getId(), null))
  3710.                 .getIdPortaApplicativa();
  3711.     }
  3712.     
  3713.     
  3714.     public static final IDPortaDelegata getIDGruppoPDDefault(IDSoggetto idFruitore, IdServizio idAsps,  AccordiServizioParteSpecificaCore apsCore ) throws Exception {
  3715.         return AccordiServizioParteSpecificaUtilities.getDefaultMappingPD(apsCore.serviziFruitoriMappingList(idFruitore,idAsps,null))
  3716.                 .getIdPortaDelegata();
  3717.     }
  3718.     
  3719.     
  3720.     public static final IDPortaDelegata getIDGruppoPD(  
  3721.             String nome,
  3722.             IDSoggetto idFruitore,
  3723.             IdServizio idAsps,  
  3724.             AccordiServizioParteSpecificaCore apsCore ) throws Exception {
  3725.         
  3726.         return getMappingGruppiPD(nome, idFruitore, idAsps, apsCore).stream()
  3727.                 .map( m -> m.getIdPortaDelegata())
  3728.                 .findFirst()
  3729.                 .orElse(null);
  3730.     }
  3731.     
  3732.     
  3733.     public static final List<String> getAzioniOccupateErogazione(IdServizio idAsps, AccordiServizioParteSpecificaCore apsCore, PorteApplicativeCore paCore) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  3734.         
  3735.          return apsCore.mappingServiziPorteAppList(idAsps,idAsps.getId(), null).stream()
  3736.             .map ( m -> {
  3737.                     try {
  3738.                         return paCore.getPortaApplicativa(m.getIdPortaApplicativa());
  3739.                     } catch (Exception e) {
  3740.                         throw new RuntimeException(e);
  3741.                     }
  3742.                 })
  3743.             .filter( pa -> pa.getAzione() != null && pa.getAzione().getAzioneDelegataList() != null )
  3744.             .flatMap( pa -> pa.getAzione().getAzioneDelegataList().stream())
  3745.             .collect(Collectors.toList());

  3747.     }
  3748.     
  3749.     public static final List<String> getAzioniDisponibiliRateLimitingPortaApplicativa(IdServizio idAsps, PortaApplicativa pa) {
  3750.         return null;
  3751.     }
  3752.     
  3753.     public static final List<String> getAzioniDisponibiliRateLimitingPortaDelegata(PortaDelegata pd, ErogazioniEnv env) {
  3754.         if (pd.getAzione() != null && pd.getAzione().getAzioneDelegataList().size() > 0) {
  3755.             return pd.getAzione().getAzioneDelegataList();
  3756.         }
  3757.         
  3758.         return null;
  3759.         
  3760.         //env.paCore.getAzioni(asps, aspc, false, false, getAzioniOccupateFruizione()));
  3761.         /*List<String> azioniAll = this.confCore.getAzioni(env.tipo_protocollo, protocolliValue,
  3762.                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(), 
  3763.                 pa.getServizio().getTipo(), pa.getServizio().getNome(), pa.getServizio().getVersione());*/
  3764.     }
  3765.     
  3766.     public static final List<String> getAzioniOccupateFruizione(IdServizio idAsps, IDSoggetto idFruitore, AccordiServizioParteSpecificaCore apsCore, PorteDelegateCore pdCore) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  3767.         
  3768.          return apsCore.serviziFruitoriMappingList(idFruitore, idAsps, null).stream()
  3769.             .map ( m -> {
  3770.                     try {
  3771.                         return pdCore.getPortaDelegata(m.getIdPortaDelegata());
  3772.                     } catch (Exception e) {
  3773.                         throw new RuntimeException(e);
  3774.                     }
  3775.                 })
  3776.             .filter( pa -> pa.getAzione() != null && pa.getAzione().getAzioneDelegataList() != null )
  3777.             .flatMap( pa -> pa.getAzione().getAzioneDelegataList().stream())
  3778.             .collect(Collectors.toList());

  3780.     }

  3782.     
  3783.     public static final List<String> getDescrizioniMappingPA(List<MappingErogazionePortaApplicativa> listaMappingErogazione) {
  3784.         return listaMappingErogazione.stream().map( m -> m.getDescrizione() ).collect(Collectors.toList() ); 
  3785.     }

  3787.     
  3788.     public static final List<String> getDescrizioniMappingPD(List<MappingFruizionePortaDelegata> listaMappingErogazione) {
  3789.         return listaMappingErogazione.stream().map( m -> m.getDescrizione() ).collect(Collectors.toList() ); 
  3790.     }



  3794.     public static final ListaApiImplAllegati findAllAllegati(String q, Integer limit, Integer offset, UriInfo uriInfo,
  3795.             final ErogazioniEnv env, final AccordoServizioParteSpecifica asps)
  3796.             throws DriverRegistroServiziException, InstantiationException, IllegalAccessException, CoreException {
  3797.         int idLista = Liste.SERVIZI_ALLEGATI;
  3798.         
  3799.         final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  3800.         final List<Documento> lista = env.apsCore.serviziAllegatiList(asps.getId().intValue(), ricerca);
  3801.         
  3802.         if ( env.findall_404 && lista.isEmpty() ) {
  3803.             throw FaultCode.NOT_FOUND.toException("Nessun allegato associato");
  3804.         }
  3805.         
  3806.         ListaApiImplAllegati ret = ListaUtils.costruisciListaPaginata(
  3807.                 uriInfo,
  3808.                 ricerca.getIndexIniziale(idLista),
  3809.                 ricerca.getPageSize(idLista), 
  3810.                 ricerca.getNumEntries(idLista), 
  3811.                 ListaApiImplAllegati.class
  3812.             );
  3813.         
  3814.         lista.forEach( d-> 
  3815.             ret.addItemsItem( ImplAllegatoToItem(
  3816.                     documentoToImplAllegato(d))
  3817.                 )
  3818.         );
  3819.         return ret;
  3820.     }



  3824.     public static final ApiImplVersioneApiView aspsToApiImplVersioneApiView(final ErogazioniEnv env,
  3825.             final AccordoServizioParteSpecifica asps)
  3826.             throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  3827.         final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3828.         
  3829.         ApiImplVersioneApiView ret = new ApiImplVersioneApiView();
  3830.         
  3831.         AccordoServizioParteComuneSintetico api = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3832.         
  3833.         ret.setApiNome(aspc.getNome());
  3834.         ret.setApiSoapServizio(asps.getPortType());
  3835.         ret.setApiVersione(aspc.getVersione());
  3836.         ret.setProfilo(env.profilo);
  3837.         ret.setSoggetto(aspc.getSoggettoReferente().getNome());
  3838.         ret.setTipoServizio(asps.getTipo());
  3839.         
  3840.           // Lista di Accordi Compatibili
  3841.         List<AccordoServizioParteComune> asParteComuneCompatibili = env.apsCore.findAccordiParteComuneBySoggettoAndNome(
  3842.                 api.getNome(),
  3843.                 new IDSoggetto(api.getSoggettoReferente().getTipo(), api.getSoggettoReferente().getNome())
  3844.             );
  3845.         
  3846.         ret.setVersioni(asParteComuneCompatibili.stream().map( a -> a.getVersione() ).collect(Collectors.toList())); 
  3847.         return ret;
  3848.     }



  3852.     public static final ApiImplInformazioniGeneraliView erogazioneToApiImplInformazioniGeneraliView(final ErogazioniEnv env,
  3853.             final AccordoServizioParteSpecifica asps) {
  3854.         ApiImplViewItem item = aspsToErogazioneViewItem(env, asps);

  3856.         ApiImplInformazioniGeneraliView ret = new ApiImplInformazioniGeneraliView();
  3857.         
  3858.         ret.setApiSoapServizio(item.getApiSoapServizio());
  3859.         ret.setNome(item.getNome());
  3860.         ret.setProfilo(item.getProfilo());
  3861.         ret.setTipo(item.getTipoServizio());
  3862.         return ret;
  3863.     }
  3864.     
  3865.     public static final ApiImplInformazioniGeneraliView fruizioneToApiImplInformazioniGeneraliView(final ErogazioniEnv env,
  3866.             final AccordoServizioParteSpecifica asps, IdSoggetto fruitore) {
  3867.         
  3868.         ApiImplViewItem item = aspsToFruizioneViewItem(env, asps, fruitore);

  3870.         ApiImplInformazioniGeneraliView ret = new ApiImplInformazioniGeneraliView();
  3871.         
  3872.         ret.setApiSoapServizio(item.getApiSoapServizio());
  3873.         ret.setNome(item.getNome());
  3874.         ret.setProfilo(item.getProfilo());
  3875.         ret.setTipo(item.getTipoServizio());
  3876.         return ret;
  3877.     }


  3880.     public static final CorsConfigurazione buildCorsConfigurazione(GestioneCors body, final ErogazioniEnv env,
  3881.             final CorsConfigurazione oldConf) throws Exception {
  3882.         
  3883.         
  3884.         final String statoCorsPorta = body.isRidefinito()
  3885.                 ?       CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO
  3886.                 :       CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  3887.         
  3888.         final GestioneCorsAccessControl c = body.getAccessControl();
  3889.         
  3890.         final String corsStato = Helper.boolToStatoFunzionalita( body.getTipo() != TipoGestioneCorsEnum.DISABILITATO ).toString();
  3891.         final TipoGestioneCORS corsTipo =  Enums.tipoGestioneCorsFromRest.get( body.getTipo() );
  3892.         final String allowOrigins = String.join(",", BaseHelper.evalorElse( () -> c.getAllowOrigins(), new ArrayList<>()) );
  3893.         final String allowHeaders = String.join(",", BaseHelper.evalorElse( () -> c.getAllowHeaders(), new ArrayList<>()) );
  3894.         final String exposeHeaders = String.join(",", BaseHelper.evalorElse( () -> c.getExposeHeaders(), new ArrayList<>()) );
  3895.         final String allowMethods = String.join(
  3896.                 ",",
  3897.                 BaseHelper.evalorElse( () -> c.getAllowMethods(), new ArrayList<HttpMethodEnum>() )
  3898.                     .stream().map( m -> m.name()).collect(Collectors.toList()) 
  3899.             );
  3900.     
  3901.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_STATO, corsStato );
  3902.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_TIPO, corsTipo.toString() );
  3903.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_ORIGINS, ServletUtils.boolToCheckBoxStatus(c.isAllAllowOrigins()) );
  3904.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_ORIGINS, allowOrigins );
  3905.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_HEADERS, ServletUtils.boolToCheckBoxStatus(c.isAllAllowHeaders()) );
  3906.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_HEADERS, allowHeaders );
  3907.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_METHODS, ServletUtils.boolToCheckBoxStatus(c.isAllAllowMethods()) );
  3908.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS, allowMethods );
  3909.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_EXPOSE_HEADERS, exposeHeaders );
  3910.         env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE, ServletUtils.boolToCheckBoxStatus(c.isMaxAge()) );
  3911.         if(c.isMaxAge()!=null && c.isMaxAge() && c.getMaxAgeSeconds()!=null) {
  3912.             env.requestWrapper.overrideParameter( CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE_SECONDS, c.getMaxAgeSeconds() );
  3913.         }
  3914.     
  3915.         if ( !env.paHelper.checkDataConfigurazioneCorsPorta(TipoOperazione.OTHER, true, statoCorsPorta) ) {
  3916.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3917.         }
  3918.         
  3919.     
  3920.         return env.paHelper.getGestioneCors(
  3921.                 body.getTipo() != TipoGestioneCorsEnum.DISABILITATO,
  3922.                 corsTipo,  
  3923.                 c.isAllAllowOrigins(), 
  3924.                 c.isAllAllowHeaders(), 
  3925.                 c.isAllAllowMethods(), 
  3926.                 allowHeaders, 
  3927.                 allowOrigins, 
  3928.                 allowMethods, 
  3929.                 c.isAllowCredentials(),
  3930.                 exposeHeaders,
  3931.                 c.isMaxAge()!=null ? c.isMaxAge() : false,
  3932.                 c.getMaxAgeSeconds()!=null ? c.getMaxAgeSeconds() : -1
  3933.             );
  3934.     }
  3935.     
  3936.     
  3937.     public static final GestioneToken buildGestioneToken(ControlloAccessiGestioneToken body, Object porta, boolean isPortaDelegata, ConsoleHelper coHelper, ErogazioniEnv env) throws Exception {
  3938.                 
  3939.         GestioneToken ret = new GestioneToken();
  3940.         
  3941.         ret.setPolicy( body.getPolicy() );
  3942.         ret.setTokenOpzionale( Helper.boolToStatoFunzionalitaConf(body.isTokenOpzionale()) ); 
  3943.         ret.setValidazione( StatoFunzionalitaConWarning.toEnumConstant(  evalnull(  () -> body.getValidazioneJwt().toString() )) );
  3944.         ret.setIntrospection( StatoFunzionalitaConWarning.toEnumConstant( evalnull( () -> body.getIntrospection().toString() )) );
  3945.         ret.setUserInfo( StatoFunzionalitaConWarning.toEnumConstant( evalnull( () -> body.getUserInfo().toString() )) );
  3946.         ret.setForward( Helper.boolToStatoFunzionalitaConf(body.isTokenForward()) );    
  3947.         
  3948.         return ret;
  3949.         
  3950.     }
  3951.     
  3952.     public static final void fillGestioneToken(GestioneToken ret, ControlloAccessiGestioneToken body) {
  3953.         ret.setPolicy( body.getPolicy() );
  3954.         ret.setTokenOpzionale( Helper.boolToStatoFunzionalitaConf(body.isTokenOpzionale()) ); 
  3955.         ret.setValidazione( StatoFunzionalitaConWarning.toEnumConstant(  evalnull(  () -> body.getValidazioneJwt().toString() )) );
  3956.         ret.setIntrospection( StatoFunzionalitaConWarning.toEnumConstant( evalnull( () -> body.getIntrospection().toString() )) );
  3957.         ret.setUserInfo( StatoFunzionalitaConWarning.toEnumConstant( evalnull( () -> body.getUserInfo().toString() )) );
  3958.         ret.setForward( Helper.boolToStatoFunzionalitaConf(body.isTokenForward()) );            
  3959.     }
  3960.     
  3961.     public static final RegistrazioneMessaggiConfigurazioneRegola fromDumpConfigurazioneRegola(DumpConfigurazioneRegola r) {
  3962.         if (r == null) return null;
  3963.         RegistrazioneMessaggiConfigurazioneRegola ret = new RegistrazioneMessaggiConfigurazioneRegola();
  3964.         
  3965.         ret.setPayload(Helper.statoFunzionalitaConfToBool( r.getPayload()) );
  3966.         ret.setHeaders(Helper.statoFunzionalitaConfToBool( r.getHeaders()) );
  3967.         if(ret.isPayload()!=null && ret.isPayload()) {
  3968.             ret.setPayloadParsing(Helper.statoFunzionalitaConfToBool( r.getPayloadParsing()) );
  3969.             if(ret.isPayloadParsing()!=null && ret.isPayloadParsing()) {
  3970.                 ret.setBody(Helper.statoFunzionalitaConfToBool( r.getBody()) );
  3971.                 ret.setAttachments(Helper.statoFunzionalitaConfToBool( r.getAttachments()) );
  3972.             }
  3973.         }
  3974.         
  3975.         return ret;
  3976.     }



  3980.     public static final ControlloAccessiAutenticazioneToken fromGestioneTokenAutenticazione(
  3981.             final GestioneTokenAutenticazione tokAut) {
  3982.         ControlloAccessiAutenticazioneToken token = new ControlloAccessiAutenticazioneToken();
  3983.         token.setClientId(Helper.statoFunzionalitaConfToBool( tokAut.getClientId() ));
  3984.         token.setEmail(Helper.statoFunzionalitaConfToBool( tokAut.getEmail() ));
  3985.         token.setIssuer(Helper.statoFunzionalitaConfToBool( tokAut.getIssuer() ));
  3986.         token.setSubject(Helper.statoFunzionalitaConfToBool( tokAut.getSubject() ));
  3987.         token.setUsername(Helper.statoFunzionalitaConfToBool(tokAut.getUsername() ));
  3988.         return token;
  3989.     }

  3991.     
  3992.     
  3993.     public static final RegistrazioneDiagnosticiConfigurazione fromDiagnosticiConfigurazione(final PortaTracciamento paTracciamento) {
  3994.         final RegistrazioneDiagnosticiConfigurazione ret = new RegistrazioneDiagnosticiConfigurazione();
  3995.         
  3996.         if (paTracciamento != null && paTracciamento.getSeverita()!=null) {
  3997.             ret.setStato(StatoDefaultRidefinitoEnum.RIDEFINITO);
  3998.             
  3999.             switch (paTracciamento.getSeverita()) {
  4000.             case ALL:
  4001.                 ret.setSeverita(DiagnosticiSeverita.ALL);
  4002.                 break;
  4003.             case DEBUG_HIGH:
  4004.                 ret.setSeverita(DiagnosticiSeverita.DEBUG_HIGH);
  4005.                 break;
  4006.             case DEBUG_MEDIUM:
  4007.                 ret.setSeverita(DiagnosticiSeverita.DEBUG_MEDIUM);
  4008.                 break;
  4009.             case DEBUG_LOW:
  4010.                 ret.setSeverita(DiagnosticiSeverita.DEBUG_LOW);
  4011.                 break;
  4012.             case INFO_PROTOCOL:
  4013.                 ret.setSeverita(DiagnosticiSeverita.INFO_PROTOCOL);
  4014.                 break;
  4015.             case INFO_INTEGRATION:
  4016.                 ret.setSeverita(DiagnosticiSeverita.INFO_INTEGRATION);
  4017.                 break;
  4018.             case ERROR_PROTOCOL:
  4019.                 ret.setSeverita(DiagnosticiSeverita.ERROR_PROTOCOL);
  4020.                 break;
  4021.             case ERROR_INTEGRATION:
  4022.                 ret.setSeverita(DiagnosticiSeverita.ERROR_INTEGRATION);
  4023.                 break;
  4024.             case FATAL:
  4025.                 ret.setSeverita(DiagnosticiSeverita.FATAL);
  4026.                 break;
  4027.             case OFF:
  4028.                 ret.setSeverita(DiagnosticiSeverita.OFF);
  4029.                 break;
  4030.             }
  4031.             
  4032.         }
  4033.         else {
  4034.             ret.setStato(StatoDefaultRidefinitoEnum.DEFAULT);
  4035.         }
  4036.         return ret;
  4037.     }
  4038.     
  4039.     
  4040.     public static final RegistrazioneTransazioniConfigurazione fromTransazioniConfigurazione(final PortaTracciamento paTracciamento, Environment env) throws ProtocolException {
  4041.         final RegistrazioneTransazioniConfigurazione ret = new RegistrazioneTransazioniConfigurazione();
  4042.         
  4043.         if (paTracciamento != null && 
  4044.                 (
  4045.                         paTracciamento.getDatabase()!=null || 
  4046.                         paTracciamento.getFiletrace()!=null ||
  4047.                         (
  4048.                                 paTracciamento.getEsiti()!=null && StringUtils.isNoneEmpty(paTracciamento.getEsiti()) &&
  4049.                                 (
  4050.                                         paTracciamento.getDatabase()!=null && StatoFunzionalita.ABILITATO.equals(paTracciamento.getDatabase().getFiltroEsiti())
  4051.                                         ||
  4052.                                         paTracciamento.getFiletrace()!=null && StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletrace().getFiltroEsiti())
  4053.                                 )
  4054.                         ) 
  4055.                         ||
  4056.                         paTracciamento.getFiletraceConfig()!=null ||
  4057.                         paTracciamento.getTransazioni()!=null
  4058.                         )
  4059.             ) {
  4060.             ret.setStato(StatoDefaultRidefinitoEnum.RIDEFINITO);
  4061.             
  4062.             if(paTracciamento.getDatabase()!=null) {
  4063.                 ret.setDatabase(fromTransazioniConfigurazioneBase(paTracciamento.getDatabase(), false));
  4064.             }
  4065.             if(paTracciamento.getFiletrace()!=null) {
  4066.                 RegistrazioneTransazioniConfigurazioneFiletrace f = (RegistrazioneTransazioniConfigurazioneFiletrace) fromTransazioniConfigurazioneBase(paTracciamento.getFiletrace(), true);
  4067.                 if(paTracciamento.getFiletraceConfig()!=null) {
  4068.                     f.setConfigPath(paTracciamento.getFiletraceConfig().getConfig());
  4069.                     if(paTracciamento.getFiletraceConfig().getDumpIn()!=null && StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletraceConfig().getDumpIn().getStato())) {
  4070.                         f.setDumpClient(new RegistrazioneTransazioniConfigurazioneFiletraceMessaggio());
  4071.                         f.getDumpClient().setHeaders(StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletraceConfig().getDumpIn().getHeader()));
  4072.                         f.getDumpClient().setPayload(StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletraceConfig().getDumpIn().getPayload()));
  4073.                     }
  4074.                     if(paTracciamento.getFiletraceConfig().getDumpOut()!=null && StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletraceConfig().getDumpOut().getStato())) {
  4075.                         f.setDumpServer(new RegistrazioneTransazioniConfigurazioneFiletraceMessaggio());
  4076.                         f.getDumpServer().setHeaders(StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletraceConfig().getDumpOut().getHeader()));
  4077.                         f.getDumpServer().setPayload(StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletraceConfig().getDumpOut().getPayload()));
  4078.                     }
  4079.                 }
  4080.                 ret.setFiletrace(f);
  4081.             }
  4082.             if((paTracciamento.getEsiti()!=null && StringUtils.isNoneEmpty(paTracciamento.getEsiti())) &&
  4083.                     (
  4084.                             paTracciamento.getDatabase()!=null && StatoFunzionalita.ABILITATO.equals(paTracciamento.getDatabase().getFiltroEsiti())
  4085.                             ||
  4086.                             paTracciamento.getFiletrace()!=null && StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiletrace().getFiltroEsiti())
  4087.                     )
  4088.                     ) {
  4089.                 Logger log = LoggerWrapperFactory.getLogger(ErogazioniApiHelper.class); 
  4090.                 List<String> esiti  = EsitiConfigUtils.getRegistrazioneEsiti(paTracciamento.getEsiti(), log, new StringBuilder(), EsitiProperties.getInstance(log, env.protocolFactory));
  4091.                 if(esiti!=null && !esiti.isEmpty()) {
  4092.                     ret.setFiltro(new RegistrazioneTransazioniConfigurazioneFiltroEsiti());
  4093.                     for (String e : esiti) {
  4094.                         ret.getFiltro().addEsitiItem(Integer.valueOf(e));       
  4095.                     }
  4096.                 }
  4097.             }
  4098.             if(paTracciamento.getTransazioni()!=null) {
  4099.                 ret.setInformazioni(new RegistrazioneTransazioniConfigurazioneInformazioniRegistrate());
  4100.                 if(paTracciamento.getTransazioni().getTempiElaborazione()!=null) {
  4101.                     if(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(paTracciamento.getTransazioni().getTempiElaborazione())) {
  4102.                         ret.getInformazioni().setTempiElaborazione(TracciamentoTransazioniStatoFase.ABILITATO);                     
  4103.                     }
  4104.                     else {
  4105.                         ret.getInformazioni().setTempiElaborazione(TracciamentoTransazioniStatoFase.DISABILITATO);                      
  4106.                     }
  4107.                 }
  4108.                 else {
  4109.                     ret.getInformazioni().setTempiElaborazione(TracciamentoTransazioniStatoFase.DISABILITATO);              
  4110.                 }
  4111.                 if(paTracciamento.getTransazioni().getToken()!=null) {
  4112.                     if(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(paTracciamento.getTransazioni().getToken())) {
  4113.                         ret.getInformazioni().setToken(TracciamentoTransazioniStatoFase.ABILITATO);                     
  4114.                     } else {
  4115.                         ret.getInformazioni().setToken(TracciamentoTransazioniStatoFase.DISABILITATO);                      
  4116.                     }
  4117.                 }
  4118.                 else {
  4119.                     ret.getInformazioni().setToken(TracciamentoTransazioniStatoFase.DISABILITATO);  
  4120.                 }
  4121.             }
  4122.             
  4123.             // check finale
  4124.             if(ret.getDatabase()==null && ret.getFiletrace()==null && ret.getFiltro()==null && ret.getInformazioni()==null) {
  4125.                 ret.setStato(StatoDefaultRidefinitoEnum.DEFAULT);
  4126.             }
  4127.         }
  4128.         else {
  4129.             ret.setStato(StatoDefaultRidefinitoEnum.DEFAULT);
  4130.         }
  4131.         return ret;
  4132.     }
  4133.     private static final RegistrazioneTransazioniConfigurazioneBase fromTransazioniConfigurazioneBase(final TracciamentoConfigurazione paTracciamento, boolean fileTrace) {
  4134.         RegistrazioneTransazioniConfigurazioneBase c = null;
  4135.         
  4136.         if(paTracciamento.getStato()!=null) {
  4137.             
  4138.             c =  fileTrace ? new RegistrazioneTransazioniConfigurazioneFiletrace() : new RegistrazioneTransazioniConfigurazioneBase();
  4139.             
  4140.             switch (paTracciamento.getStato()) {
  4141.             case ABILITATO:
  4142.                 c.setStato(TracciamentoTransazioniStato.ABILITATO);
  4143.                 break;
  4144.             case DISABILITATO:
  4145.                 c.setStato(TracciamentoTransazioniStato.DISABILITATO);
  4146.                 break;
  4147.             case CONFIGURAZIONE_ESTERNA:
  4148.                 c.setStato(TracciamentoTransazioniStato.CONFIGURAZIONEESTERNA);
  4149.                 break;
  4150.             case PERSONALIZZATO:
  4151.                 c.setStato(TracciamentoTransazioniStato.PERSONALIZZATO);
  4152.                 
  4153.                 c.setFasi(new RegistrazioneTransazioniConfigurazioneFasi());
  4154.                 
  4155.                 if(paTracciamento.getRequestIn()!=null) {
  4156.                     switch (paTracciamento.getRequestIn()) {
  4157.                         case ABILITATO:
  4158.                             c.getFasi().setRichiestaIngresso(TracciamentoTransazioniStatoFaseBloccante.BLOCCANTE);
  4159.                             break;
  4160.                         case NON_BLOCCANTE:
  4161.                             c.getFasi().setRichiestaIngresso(TracciamentoTransazioniStatoFaseBloccante.NON_BLOCCANTE);
  4162.                             break;
  4163.                         case DISABILITATO:
  4164.                             c.getFasi().setRichiestaIngresso(TracciamentoTransazioniStatoFaseBloccante.DISABILITATO);
  4165.                             break;
  4166.                     }
  4167.                 }
  4168.                 else {
  4169.                     c.getFasi().setRichiestaIngresso(TracciamentoTransazioniStatoFaseBloccante.DISABILITATO);
  4170.                 }
  4171.                 
  4172.                 if(paTracciamento.getRequestOut()!=null) {
  4173.                     switch (paTracciamento.getRequestOut()) {
  4174.                         case ABILITATO:
  4175.                             c.getFasi().setRichiestaUscita(TracciamentoTransazioniStatoFaseBloccante.BLOCCANTE);
  4176.                             break;
  4177.                         case NON_BLOCCANTE:
  4178.                             c.getFasi().setRichiestaUscita(TracciamentoTransazioniStatoFaseBloccante.NON_BLOCCANTE);
  4179.                             break;
  4180.                         case DISABILITATO:
  4181.                             c.getFasi().setRichiestaUscita(TracciamentoTransazioniStatoFaseBloccante.DISABILITATO);
  4182.                             break;
  4183.                     }
  4184.                 }
  4185.                 else {
  4186.                     c.getFasi().setRichiestaUscita(TracciamentoTransazioniStatoFaseBloccante.DISABILITATO);
  4187.                 }
  4188.                 
  4189.                 if(paTracciamento.getResponseOut()!=null) {
  4190.                     switch (paTracciamento.getResponseOut()) {
  4191.                         case ABILITATO:
  4192.                             c.getFasi().setRispostaUscita(TracciamentoTransazioniStatoFaseBloccante.BLOCCANTE);
  4193.                             break;
  4194.                         case NON_BLOCCANTE:
  4195.                             c.getFasi().setRispostaUscita(TracciamentoTransazioniStatoFaseBloccante.NON_BLOCCANTE);
  4196.                             break;
  4197.                         case DISABILITATO:
  4198.                             c.getFasi().setRispostaUscita(TracciamentoTransazioniStatoFaseBloccante.DISABILITATO);
  4199.                             break;
  4200.                     }
  4201.                 }
  4202.                 else {
  4203.                     c.getFasi().setRispostaUscita(TracciamentoTransazioniStatoFaseBloccante.DISABILITATO);
  4204.                 }
  4205.                 
  4206.                 if(paTracciamento.getResponseOutComplete()!=null) {
  4207.                     if(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(paTracciamento.getResponseOutComplete())) {
  4208.                         c.getFasi().setRispostaConsegnata(TracciamentoTransazioniStatoFase.ABILITATO);
  4209.                     }else {
  4210.                         c.getFasi().setRispostaConsegnata(TracciamentoTransazioniStatoFase.DISABILITATO);
  4211.                     }
  4212.                 }
  4213.                 else {
  4214.                     c.getFasi().setRispostaConsegnata(TracciamentoTransazioniStatoFase.DISABILITATO);
  4215.                 }
  4216.                 
  4217.                 break;
  4218.             }
  4219.                         
  4220.             if(paTracciamento.getFiltroEsiti()!=null) {
  4221.                 if(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(paTracciamento.getFiltroEsiti())) {
  4222.                     c.setFiltroEsiti(TracciamentoTransazioniStatoFase.ABILITATO);
  4223.                 }
  4224.                 else{
  4225.                     c.setFiltroEsiti(TracciamentoTransazioniStatoFase.DISABILITATO);
  4226.                 }
  4227.             }
  4228.             
  4229.         }
  4230.         
  4231.         return c;
  4232.     }


  4235.     public static final RegistrazioneMessaggi fromDumpConfigurazione(final DumpConfigurazione paDump) {
  4236.         final RegistrazioneMessaggi ret = new RegistrazioneMessaggi();
  4237.         
  4238.         if (paDump != null) {
  4239.             ret.setStato(StatoDefaultRidefinitoEnum.RIDEFINITO);
  4240.             
  4241.             final RegistrazioneMessaggiConfigurazione richiesta = new RegistrazioneMessaggiConfigurazione();
  4242.             
  4243.             richiesta.setAbilitato( isDumpConfigurazioneAbilitato(paDump, false) );
  4244.             if ( richiesta.isAbilitato() ) {
  4245.                 richiesta.setIngresso( fromDumpConfigurazioneRegola(paDump.getRichiestaIngresso()));
  4246.                 richiesta.setUscita( fromDumpConfigurazioneRegola(paDump.getRichiestaUscita()));
  4247.             }
  4248.             
  4249.             ret.setRichiesta(richiesta);
  4250.                             
  4251.             RegistrazioneMessaggiConfigurazione risposta = new RegistrazioneMessaggiConfigurazione();
  4252.             risposta.setAbilitato( isDumpConfigurazioneAbilitato(paDump,true) );
  4253.             if (risposta.isAbilitato()) {
  4254.                 risposta.setIngresso( fromDumpConfigurazioneRegola( paDump.getRispostaIngresso()) );
  4255.                 risposta.setUscita( fromDumpConfigurazioneRegola( paDump.getRispostaUscita()) );
  4256.             }
  4257.             
  4258.             ret.setRisposta(risposta);              
  4259.         }
  4260.         else {
  4261.             ret.setStato(StatoDefaultRidefinitoEnum.DEFAULT);
  4262.         }
  4263.         return ret;
  4264.     }



  4268.     public static final Validazione fromValidazioneContenutiApplicativi(final ValidazioneContenutiApplicativi vx) {
  4269.         final Validazione ret = new Validazione();
  4270.         
  4271.         if (vx == null) {
  4272.             ret.setStato(StatoFunzionalitaConWarningEnum.DISABILITATO);
  4273.         } else {

  4275.             ret.setMtom( Helper.statoFunzionalitaConfToBool(vx.getAcceptMtomMessage()) );
  4276.             ret.setStato( StatoFunzionalitaConWarningEnum.valueOf(vx.getStato().name()));
  4277.             ret.setTipo(  TipoValidazioneEnum.valueOf(vx.getTipo().name()) );
  4278.         }
  4279.         return ret;
  4280.     }


  4283.     public static final String readHeadersResponseCaching(List<String> headers) {
  4284.         if(headers==null || headers.isEmpty()) {
  4285.             return null;
  4286.         }
  4287.         StringBuilder  bf = new StringBuilder();
  4288.         for (String hdr : headers) {
  4289.             if(bf.length()>0) {
  4290.                 bf.append(",");
  4291.             }
  4292.             bf.append(hdr);
  4293.         }
  4294.         return bf.toString();
  4295.     }
  4296.     
  4297.     public static final List<ResponseCachingConfigurazioneRegola> getRegoleResponseCaching(List<CachingRispostaRegola> regole){
  4298.         if(regole==null || regole.isEmpty()) {
  4299.             return null;
  4300.         }
  4301.         List<ResponseCachingConfigurazioneRegola> returnList = new ArrayList<>();
  4302.         for (CachingRispostaRegola cachingRispostaRegola : regole) {
  4303.             ResponseCachingConfigurazioneRegola rule = new ResponseCachingConfigurazioneRegola();
  4304.             if(cachingRispostaRegola.getReturnCodeMin()!=null)
  4305.                 rule.setReturnCodeMin(cachingRispostaRegola.getReturnCodeMin());
  4306.             if(cachingRispostaRegola.getReturnCodeMax()!=null)
  4307.                 rule.setReturnCodeMax(cachingRispostaRegola.getReturnCodeMax());
  4308.             rule.setFault(cachingRispostaRegola.isFault());
  4309.             if(cachingRispostaRegola.getCacheTimeoutSeconds()!=null)
  4310.                 rule.setCacheTimeoutSeconds(cachingRispostaRegola.getCacheTimeoutSeconds());
  4311.             returnList.add(rule);
  4312.         }
  4313.         return returnList;
  4314.     }

  4316.     public static final ResponseCachingConfigurazione buildResponseCachingConfigurazione(CachingRisposta body, PorteApplicativeHelper paHelper) {
  4317.         ResponseCachingConfigurazione newConfigurazione = null;
  4318.         if (body.getStato() == StatoDefaultRidefinitoEnum.DEFAULT) {
  4319.             
  4320.         }
  4321.         
  4322.         else if ( body.getStato() == StatoDefaultRidefinitoEnum.RIDEFINITO ) {
  4323.             newConfigurazione = paHelper.getResponseCaching(
  4324.                     body.isAbilitato(),  // responseCachingEnabled
  4325.                     body.getCacheTimeoutSeconds(), // responseCachingSeconds
  4326.                     body.isMaxResponseSize(), // responseCachingMaxResponseSize
  4327.                     body.getMaxResponseSizeKb(), // responseCachingMaxResponseSizeBytes
  4328.                     body.isHashRequestUri(), // responseCachingDigestUrlInvocazione
  4329.                     (readHeadersResponseCaching(body.getHashHeaders())!=null), // responseCachingDigestHeaders
  4330.                     body.isHashPayload(), // responseCachingDigestPayload
  4331.                     readHeadersResponseCaching(body.getHashHeaders()), // responseCachingDigestHeadersNomiHeaders
  4332.                     convertToStatoFunzionalitaCacheDigestQueryParameter(body),//responseCachingDigestQueryParameter
  4333.                     readHeadersResponseCaching(body.getHashQueryParamaters()), // responseCachingDigestNomiParametriQuery
  4334.                     body.isControlNoCache(), // responseCachingCacheControlNoCache
  4335.                     body.isControlMaxAge(), // responseCachingCacheControlMaxAge
  4336.                     body.isControlNoStore(), // responseCachingCacheControlNoStore
  4337.                     getRegoleResponseCaching(body.getRegole())// listaRegoleCachingConfigurazione
  4338.                 );
  4339.         }
  4340.         return newConfigurazione;
  4341.     }
  4342.     
  4343.     private static final StatoFunzionalitaCacheDigestQueryParameter convertToStatoFunzionalitaCacheDigestQueryParameter(CachingRisposta body) {
  4344.         if(body!=null && body.isHashAllQueryParameters()!=null) {
  4345.             if(body.isHashAllQueryParameters()) {
  4346.                 return StatoFunzionalitaCacheDigestQueryParameter.ABILITATO;
  4347.             }
  4348.             else {
  4349.                 if(body.getHashQueryParamaters()!=null && !body.getHashQueryParamaters().isEmpty()) {
  4350.                     return StatoFunzionalitaCacheDigestQueryParameter.SELEZIONE_PUNTUALE;
  4351.                 }
  4352.                 else {
  4353.                     return StatoFunzionalitaCacheDigestQueryParameter.DISABILITATO;
  4354.                 }
  4355.             }
  4356.         }
  4357.         else {
  4358.             // default
  4359.             return StatoFunzionalitaCacheDigestQueryParameter.ABILITATO;
  4360.         }
  4361.     }
  4362.     
  4363.     public static final CachingRisposta buildCachingRisposta(ResponseCachingConfigurazione conf) {
  4364.         CachingRisposta ret = new CachingRisposta();
  4365.         
  4366.         if (conf == null) {
  4367.             ret.setStato(StatoDefaultRidefinitoEnum.DEFAULT);
  4368.             ret.setAbilitato(false);
  4369.             ret.setHashHeaders(null);
  4370.             ret.setHashPayload(null);
  4371.             ret.setHashRequestUri(null);
  4372.             ret.setHashAllQueryParameters(null);
  4373.             return ret;
  4374.         }
  4375.         
  4376.         ret.setAbilitato(conf.getStato() == StatoFunzionalita.ABILITATO);
  4377.         ret.setStato( conf.getStato() == StatoFunzionalita.ABILITATO
  4378.                 ? StatoDefaultRidefinitoEnum.RIDEFINITO
  4379.                 : StatoDefaultRidefinitoEnum.DEFAULT
  4380.             );
  4381.         ret.setCacheTimeoutSeconds(conf.getCacheTimeoutSeconds());
  4382.         
  4383.         if (ret.isAbilitato()) {
  4384.             
  4385.             ret.setMaxResponseSize( conf.getMaxMessageSize() != null);
  4386.             ret.setMaxResponseSizeKb( conf.getMaxMessageSize() );
  4387.             
  4388.             ResponseCachingConfigurazioneHashGenerator hashInfo = conf.getHashGenerator();
  4389.             if(hashInfo.getQueryParameters()!=null) {
  4390.                 switch (hashInfo.getQueryParameters()) {
  4391.                 case ABILITATO:
  4392.                     ret.setHashAllQueryParameters(true);
  4393.                     break;
  4394.                 case DISABILITATO:
  4395.                     ret.setHashAllQueryParameters(false);
  4396.                     break;
  4397.                 case SELEZIONE_PUNTUALE:
  4398.                     ret.setHashAllQueryParameters(false);
  4399.                     if(hashInfo.sizeQueryParameterList()>0) {
  4400.                         ret.setHashQueryParamaters(hashInfo.getQueryParameterList());
  4401.                     }
  4402.                     break;
  4403.                 }
  4404.             }
  4405.             if(StatoFunzionalita.ABILITATO.equals(hashInfo.getHeaders())) {
  4406.                 if(hashInfo.sizeHeaderList()>0) {
  4407.                     ret.setHashHeaders(hashInfo.getHeaderList());
  4408.                 }
  4409.             }
  4410.             ret.setHashPayload(Helper.statoFunzionalitaConfToBool(hashInfo.getPayload()));
  4411.             ret.setHashRequestUri(Helper.statoFunzionalitaConfToBool(hashInfo.getRequestUri()));
  4412.             
  4413.             if(conf.getControl()!=null) {
  4414.                 ret.setControlNoCache(conf.getControl().isNoCache());
  4415.                 ret.setControlMaxAge(conf.getControl().isMaxAge());
  4416.                 ret.setControlNoStore(conf.getControl().isNoStore());
  4417.             }
  4418.             
  4419.             if(conf.sizeRegolaList()>0) {
  4420.                 ret.setRegole(new ArrayList<CachingRispostaRegola>());
  4421.                 
  4422.                 for (ResponseCachingConfigurazioneRegola regola : conf.getRegolaList()) {
  4423.                     CachingRispostaRegola cachingRispostaRegola = new CachingRispostaRegola();
  4424.                     if(regola.getReturnCodeMin()!=null) {
  4425.                         cachingRispostaRegola.setReturnCodeMin(regola.getReturnCodeMin());
  4426.                     }
  4427.                     if(regola.getReturnCodeMax()!=null) {
  4428.                         cachingRispostaRegola.setReturnCodeMax(regola.getReturnCodeMax());
  4429.                     }
  4430.                     cachingRispostaRegola.setFault(regola.isFault());
  4431.                     if(regola.getCacheTimeoutSeconds()!=null) {
  4432.                         cachingRispostaRegola.setCacheTimeoutSeconds(regola.getCacheTimeoutSeconds());
  4433.                     }
  4434.                     ret.addRegoleItem(cachingRispostaRegola);
  4435.                 }
  4436.             }
  4437.         }
  4438.         
  4439.         return ret;
  4440.     }


  4443.     
  4444.     @Deprecated 
  4445.     public static final RuoloTipologia ruoloTipologiaFromAutorizzazione(final String autorizzazione) {
  4446.         RuoloTipologia tipoRuoloFonte = null;
  4447.         if (TipoAutorizzazione.isRolesRequired(autorizzazione)) {
  4448.             if ( TipoAutorizzazione.isExternalRolesRequired(autorizzazione) )
  4449.                 tipoRuoloFonte = RuoloTipologia.ESTERNO;
  4450.             else if ( TipoAutorizzazione.isInternalRolesRequired(autorizzazione))
  4451.                 tipoRuoloFonte = RuoloTipologia.INTERNO;
  4452.             else
  4453.                 tipoRuoloFonte = RuoloTipologia.QUALSIASI;              
  4454.         }
  4455.         return tipoRuoloFonte;
  4456.     }
  4457.     
  4458.     
  4459.     public static final boolean controlloAccessiCheckPD(FruizioniConfEnv env, PortaDelegata oldPd, PortaDelegata newPd) throws Exception {
  4460.         final BinaryParameter allegatoXacmlPolicy = new BinaryParameter();
  4461.         
  4462.         allegatoXacmlPolicy.setValue( BaseHelper.evalorElse(
  4463.                 () -> newPd.getXacmlPolicy(),
  4464.                 ""
  4465.                 ).getBytes()
  4466.             );
  4467.         RuoloTipologia tipoRuoloFonte = AutorizzazioneUtilities.convertToRuoloTipologia(TipoAutorizzazione.toEnumConstant(newPd.getAutorizzazione()));
  4468.         String stato_autorizzazione = null;
  4469.         if (TipoAutorizzazione.toEnumConstant(newPd.getAutorizzazione()) != null) {
  4470.             stato_autorizzazione = AutorizzazioneUtilities.convertToStato(newPd.getAutorizzazione());
  4471.         }
  4472.         
  4473.         boolean tokenAbilitato = newPd.getGestioneToken() != null;
  4474.         boolean autorizzazioneScope = newPd.getScope() != null;
  4475.         
  4476.         if ( autorizzazioneScope && !tokenAbilitato ) {
  4477.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione per scope richiede una token policy abilitata");
  4478.         }
  4479.         
  4480.         TipoAutenticazionePrincipal autenticazionePrincipal = env.pdCore.getTipoAutenticazionePrincipal(newPd.getProprietaAutenticazioneList());
  4481.         List<String> autenticazioneParametroList = env.pdCore.getParametroAutenticazione(newPd.getAutenticazione(), newPd.getProprietaAutenticazioneList());
  4482.             
  4483.         String autorizzazioneContenutiStato = null;
  4484.         String autorizzazioneContenuti = newPd.getAutorizzazioneContenuto();
  4485.         String autorizzazioneContenutiProperties = null;
  4486.         if(autorizzazioneContenuti == null) {
  4487.             autorizzazioneContenutiStato = StatoFunzionalita.DISABILITATO.getValue();
  4488.         } else if(autorizzazioneContenuti.equals(CostantiAutorizzazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN)) {
  4489.             autorizzazioneContenutiStato = StatoFunzionalita.ABILITATO.getValue();
  4490.             List<Proprieta> proprietaAutorizzazioneContenutoList = newPd.getProprietaAutorizzazioneContenutoList();
  4491.             StringBuilder sb = new StringBuilder();
  4492.             for (Proprieta proprieta : proprietaAutorizzazioneContenutoList) {
  4493.                 if(sb.length() >0)
  4494.                     sb.append("\n");
  4495.                 
  4496.                 sb.append(proprieta.getNome()).append("=").append(proprieta.getValore()); 
  4497.             }                       
  4498.             
  4499.             autorizzazioneContenutiProperties = sb.toString();
  4500.         } else { // custom
  4501.             autorizzazioneContenutiStato = CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM;
  4502.         }
  4503.         
  4504.         String identificazioneAttributiStato = newPd.sizeAttributeAuthorityList()>0 ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue();
  4505.         String [] attributeAuthoritySelezionate = null; 
  4506.         String attributeAuthorityAttributi = null;
  4507.         if(newPd.sizeAttributeAuthorityList()>0) {
  4508.             List<String> l = new ArrayList<>();
  4509.             for (AttributeAuthority aa : newPd.getAttributeAuthorityList()) {
  4510.                 l.add(aa.getNome());
  4511.             }
  4512.             attributeAuthoritySelezionate = l.toArray(new String[1]);
  4513.             attributeAuthorityAttributi = env.apsCore.buildAttributesStringFromAuthority(newPd.getAttributeAuthorityList());
  4514.         }
  4515.         
  4516.         String autorizzazioneAutenticatiToken = null;
  4517.         String autorizzazioneRuoliToken = null;
  4518.         if(newPd.getAutorizzazioneToken()!=null) {
  4519.             autorizzazioneAutenticatiToken = ServletUtils.boolToCheckBoxStatus(StatoFunzionalita.ABILITATO.equals(newPd.getAutorizzazioneToken().getAutorizzazioneApplicativi()));
  4520.             autorizzazioneRuoliToken = ServletUtils.boolToCheckBoxStatus(StatoFunzionalita.ABILITATO.equals(newPd.getAutorizzazioneToken().getAutorizzazioneRuoli()));
  4521.         }
  4522.         
  4523.         return env.paHelper.controlloAccessiCheck(
  4524.                 TipoOperazione.OTHER, 
  4525.                 newPd.getAutenticazione(),              // Autenticazione
  4526.                 ServletUtils.boolToCheckBoxStatus( Helper.statoFunzionalitaConfToBool( newPd.getAutenticazioneOpzionale() ) ),      // Autenticazione Opzionale
  4527.                 autenticazionePrincipal,
  4528.                 autenticazioneParametroList,
  4529.                 stato_autorizzazione,               
  4530.                 ServletUtils.boolToCheckBoxStatus( TipoAutorizzazione.isAuthenticationRequired(newPd.getAutorizzazione()) ), 
  4531.                 ServletUtils.boolToCheckBoxStatus( TipoAutorizzazione.isRolesRequired(newPd.getAutorizzazione()) ), 
  4532.                 evalnull( () -> tipoRuoloFonte.toString() ), 
  4533.                 evalnull( () -> newPd.getRuoli().getMatch().toString() ), 
  4534.                 env.isSupportatoAutenticazioneSoggetti, 
  4535.                 true,       // isPortaDelegata, 
  4536.                 oldPd,
  4537.                 evalnull( () ->
  4538.                         newPd.getRuoli().getRuoloList().stream().map(Ruolo::getNome).collect(Collectors.toList())
  4539.                     ),
  4540.                 Helper.boolToStatoFunzionalita(tokenAbilitato).getValue(),
  4541.                 evalnull( () -> newPd.getGestioneToken().getPolicy() ), 
  4542.                 evalnull( () -> newPd.getGestioneToken().getValidazione().toString() ), 
  4543.                 evalnull( () -> newPd.getGestioneToken().getIntrospection().toString() ), 
  4544.                 evalnull( () -> newPd.getGestioneToken().getUserInfo().toString() ),
  4545.                 evalnull( () -> newPd.getGestioneToken().getForward().toString() ),
  4546.                 autorizzazioneAutenticatiToken, 
  4547.                 autorizzazioneRuoliToken, 
  4548.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( newPd.getGestioneToken().getOptions() != null ) ),
  4549.                 evalnull( () -> newPd.getGestioneToken().getOptions() ),
  4550.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( autorizzazioneScope ) ),
  4551.                 evalnull( () -> newPd.getScope().getMatch().toString() ),
  4552.                 allegatoXacmlPolicy,
  4553.                 autorizzazioneContenutiStato, autorizzazioneContenuti, autorizzazioneContenutiProperties,
  4554.                 env.tipo_protocollo,
  4555.                 identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  4556.     }



  4560.     public static final boolean controlloAccessiCheckPA(ErogazioniConfEnv env, PortaApplicativa oldPa, PortaApplicativa newPa)
  4561.             throws Exception {
  4562.         
  4563.         final BinaryParameter allegatoXacmlPolicy = new BinaryParameter();
  4564.         
  4565.         allegatoXacmlPolicy.setValue( BaseHelper.evalorElse(
  4566.                 () -> newPa.getXacmlPolicy(),
  4567.                 ""
  4568.                 ).getBytes()
  4569.             );
  4570.         RuoloTipologia tipoRuoloFonte = AutorizzazioneUtilities.convertToRuoloTipologia(TipoAutorizzazione.toEnumConstant(newPa.getAutorizzazione()));
  4571.         String stato_autorizzazione = null;
  4572.         if (TipoAutorizzazione.toEnumConstant(newPa.getAutorizzazione()) != null) {
  4573.             stato_autorizzazione = AutorizzazioneUtilities.convertToStato(newPa.getAutorizzazione());
  4574.         }
  4575.         
  4576.         boolean tokenAbilitato = newPa.getGestioneToken() != null;
  4577.         boolean autorizzazioneScope = newPa.getScope() != null;
  4578.         
  4579.         if ( autorizzazioneScope && !tokenAbilitato ) {
  4580.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione per scope richiede una token policy abilitata");
  4581.         }
  4582.         
  4583.         TipoAutenticazionePrincipal autenticazionePrincipal = env.paCore.getTipoAutenticazionePrincipal(newPa.getProprietaAutenticazioneList());
  4584.         List<String> autenticazioneParametroList = env.paCore.getParametroAutenticazione(newPa.getAutenticazione(), newPa.getProprietaAutenticazioneList());
  4585.         
  4586.         String autorizzazioneContenutiStato = null;
  4587.         String autorizzazioneContenuti = newPa.getAutorizzazioneContenuto();
  4588.         String autorizzazioneContenutiProperties = null;
  4589.         if(autorizzazioneContenuti == null) {
  4590.             autorizzazioneContenutiStato = StatoFunzionalita.DISABILITATO.getValue();
  4591.         } else if(autorizzazioneContenuti.equals(CostantiAutorizzazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN)) {
  4592.             autorizzazioneContenutiStato = StatoFunzionalita.ABILITATO.getValue();
  4593.             List<Proprieta> proprietaAutorizzazioneContenutoList = newPa.getProprietaAutorizzazioneContenutoList();
  4594.             StringBuilder sb = new StringBuilder();
  4595.             for (Proprieta proprieta : proprietaAutorizzazioneContenutoList) {
  4596.                 if(sb.length() >0)
  4597.                     sb.append("\n");
  4598.                 
  4599.                 sb.append(proprieta.getNome()).append("=").append(proprieta.getValore()); 
  4600.             }                       
  4601.             
  4602.             autorizzazioneContenutiProperties = sb.toString();
  4603.         } else { // custom
  4604.             autorizzazioneContenutiStato = CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM;
  4605.         }
  4606.         
  4607.         String identificazioneAttributiStato = newPa.sizeAttributeAuthorityList()>0 ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue();
  4608.         String [] attributeAuthoritySelezionate = null; 
  4609.         String attributeAuthorityAttributi = null;
  4610.         if(newPa.sizeAttributeAuthorityList()>0) {
  4611.             List<String> l = new ArrayList<>();
  4612.             for (AttributeAuthority aa : newPa.getAttributeAuthorityList()) {
  4613.                 l.add(aa.getNome());
  4614.             }
  4615.             attributeAuthoritySelezionate = l.toArray(new String[1]);
  4616.             attributeAuthorityAttributi = env.apsCore.buildAttributesStringFromAuthority(newPa.getAttributeAuthorityList());
  4617.         }
  4618.         
  4619.         String autorizzazioneAutenticatiToken = null;
  4620.         String autorizzazioneRuoliToken = null;
  4621.         if(newPa.getAutorizzazioneToken()!=null) {
  4622.             autorizzazioneAutenticatiToken = ServletUtils.boolToCheckBoxStatus(StatoFunzionalita.ABILITATO.equals(newPa.getAutorizzazioneToken().getAutorizzazioneApplicativi()));
  4623.             autorizzazioneRuoliToken = ServletUtils.boolToCheckBoxStatus(StatoFunzionalita.ABILITATO.equals(newPa.getAutorizzazioneToken().getAutorizzazioneRuoli()));
  4624.         }
  4625.         
  4626.         return env.paHelper.controlloAccessiCheck(
  4627.                 TipoOperazione.OTHER, 
  4628.                 newPa.getAutenticazione(),              // Autenticazione
  4629.                 ServletUtils.boolToCheckBoxStatus( Helper.statoFunzionalitaConfToBool( newPa.getAutenticazioneOpzionale() ) ),      // Autenticazione Opzionale
  4630.                 autenticazionePrincipal,
  4631.                 autenticazioneParametroList,
  4632.                 stato_autorizzazione,               
  4633.                 ServletUtils.boolToCheckBoxStatus( TipoAutorizzazione.isAuthenticationRequired(newPa.getAutorizzazione()) ), 
  4634.                 ServletUtils.boolToCheckBoxStatus( TipoAutorizzazione.isRolesRequired(newPa.getAutorizzazione()) ), 
  4635.                 evalnull( () -> tipoRuoloFonte.toString() ), 
  4636.                 evalnull( () -> newPa.getRuoli().getMatch().toString() ), 
  4637.                 env.isSupportatoAutenticazioneSoggetti, 
  4638.                 false,      // isPortaDelegata, 
  4639.                 oldPa,
  4640.                 evalnull( () ->
  4641.                         newPa.getRuoli().getRuoloList().stream().map(Ruolo::getNome).collect(Collectors.toList())
  4642.                     ),
  4643.                 Helper.boolToStatoFunzionalita(tokenAbilitato).getValue(),  // gestioneToken
  4644.                 evalnull( () -> newPa.getGestioneToken().getPolicy() ),     // policy
  4645.                 evalnull( () -> newPa.getGestioneToken().getValidazione().toString() ), // validazioneInput 
  4646.                 evalnull( () -> newPa.getGestioneToken().getIntrospection().toString() ), // introspection
  4647.                 evalnull( () -> newPa.getGestioneToken().getUserInfo().toString() ),        // userInfo
  4648.                 evalnull( () -> newPa.getGestioneToken().getForward().toString() ),     // forward
  4649.                 autorizzazioneAutenticatiToken, 
  4650.                 autorizzazioneRuoliToken, 
  4651.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( newPa.getGestioneToken().getOptions() != null ) ),   // autorizzazioneToken
  4652.                 evalnull( () -> newPa.getGestioneToken().getOptions() ),
  4653.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( autorizzazioneScope ) ),
  4654.                 evalnull( () -> newPa.getScope().getMatch().toString() ),
  4655.                 allegatoXacmlPolicy,
  4656.                 autorizzazioneContenutiStato, autorizzazioneContenuti, autorizzazioneContenutiProperties,
  4657.                 env.tipo_protocollo,
  4658.                 identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  4659.         
  4660.     }
  4661.     
  4662.     public static final void fillPortaDelegata(ControlloAccessiAutorizzazione body, final PortaDelegata newPd) {
  4663.         final OneOfControlloAccessiAutorizzazioneAutorizzazione authz = body.getAutorizzazione();
  4664.         
  4665.         newPd.setXacmlPolicy(null);
  4666.         
  4667.         switch (authz.getTipo()) {
  4668.         case DISABILITATO: {
  4669.             
  4670.             final String tipoAutorString = TipoAutorizzazione.DISABILITATO.toString();
  4671.             newPd.setRuoli(null);
  4672.             newPd.setScope(null);
  4673.             newPd.setAutorizzazione(tipoAutorString);
  4674.             break;
  4675.         }
  4676.         case ABILITATO: {
  4677.             
  4678.             if(! (authz instanceof APIImplAutorizzazioneAbilitata)) {
  4679.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  4680.             }
  4681.             APIImplAutorizzazioneAbilitata authzAbilitata = (APIImplAutorizzazioneAbilitata) authz;

  4683.             
  4684.             // defaults
  4685.             if ( authzAbilitata.isRuoli() && authzAbilitata.getRuoliFonte() == null ) {
  4686.                 authzAbilitata.setRuoliFonte(FonteEnum.QUALSIASI);
  4687.             }
  4688.             
  4689.             final String autorizzazione = AutorizzazioneUtilities.STATO_ABILITATO;
  4690.             
  4691.             final String autorizzazioneAutenticati = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isRichiedente());
  4692.             
  4693.             final String autorizzazioneRuoli = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isRuoli());
  4694.             final RuoloTipologia tipoRuoloFonte = Enums.ruoloTipologiaFromRest.get(authzAbilitata.getRuoliFonte());
  4695.             RuoloTipoMatch tipoRuoloMatch = null;
  4696.             if(authzAbilitata.getRuoliRichiesti()!=null) {
  4697.                 tipoRuoloMatch = RuoloTipoMatch.toEnumConstant( evalnull( () -> authzAbilitata.getRuoliRichiesti().toString()) );   // Gli enum coincidono
  4698.             }
  4699.             
  4700.             final String autorizzazioneTokenAutenticati = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isTokenRichiedente());
  4701.             
  4702.             final String autorizzazioneTokenRuoli = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isTokenRuoli());
  4703.             final org.openspcoop2.core.config.constants.RuoloTipologia tipoTokenRuoloFonte = Enums.ruoloTipologiaConfigFromRest.get(authzAbilitata.getTokenRuoliFonte());
  4704.             RuoloTipoMatch tipoTokenRuoloMatch = null;
  4705.             if(authzAbilitata.getTokenRuoliRichiesti()!=null) {
  4706.                 tipoTokenRuoloMatch = RuoloTipoMatch.toEnumConstant( evalnull( () -> authzAbilitata.getTokenRuoliRichiesti().toString()) ); // Gli enum coincidono
  4707.             }
  4708.             
  4709.             final String autorizzazioneScope = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isScope());
  4710.             final ScopeTipoMatch scopeTipoMatch = ScopeTipoMatch.toEnumConstant( evalnull( () -> authzAbilitata.getScopeRichiesti().toString()) );
  4711.             
  4712.             String autorizzazione_tokenOptions = null;
  4713.             if(authzAbilitata.getTokenClaims()!=null && !authzAbilitata.getTokenClaims().isEmpty()) {
  4714.                 autorizzazione_tokenOptions = String.join("\n", authzAbilitata.getTokenClaims());
  4715.             }
  4716.             
  4717.             
  4718.             final String tipoAutorString =  AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString(autorizzazione,
  4719.                     ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati), ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli),
  4720.                     ServletUtils.isCheckBoxEnabled(autorizzazioneTokenAutenticati), ServletUtils.isCheckBoxEnabled(autorizzazioneTokenRuoli),       
  4721.                     ServletUtils.isCheckBoxEnabled(autorizzazioneScope),        
  4722.                     autorizzazione_tokenOptions,                    // Questo è il token claims
  4723.                     tipoRuoloFonte                                  // RuoliFonte: Qualsiasi, Registro, Esterna
  4724.                 );
  4725.             
  4726.             newPd.setAutorizzazione(tipoAutorString);
  4727.             
  4728.             if ( authzAbilitata.isRuoli() ) {
  4729.                 if ( newPd.getRuoli() == null) newPd.setRuoli(new AutorizzazioneRuoli());
  4730.                 
  4731.                 newPd.getRuoli().setMatch(tipoRuoloMatch);
  4732.             } else {
  4733.                 newPd.setRuoli(null);
  4734.             }
  4735.             
  4736.             if(authzAbilitata.isTokenRichiedente() || authzAbilitata.isTokenRuoli()) {
  4737.                 newPd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  4738.                 
  4739.                 if(authzAbilitata.isTokenRichiedente()) {
  4740.                     newPd.getAutorizzazioneToken().setAutorizzazioneApplicativi(StatoFunzionalita.ABILITATO);
  4741.                 }
  4742.                 
  4743.                 if(authzAbilitata.isTokenRuoli()) {
  4744.                     newPd.getAutorizzazioneToken().setAutorizzazioneRuoli(StatoFunzionalita.ABILITATO);
  4745.                     newPd.getAutorizzazioneToken().setTipologiaRuoli(tipoTokenRuoloFonte);
  4746.                     if(newPd.getAutorizzazioneToken().getRuoli()==null) {
  4747.                         newPd.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  4748.                     }
  4749.                     newPd.getAutorizzazioneToken().getRuoli().setMatch(tipoTokenRuoloMatch);
  4750.                 }
  4751.             }
  4752.             
  4753.             if ( authzAbilitata.isScope() ) {
  4754.                 if ( newPd.getScope() == null ) newPd.setScope(new AutorizzazioneScope());
  4755.                 
  4756.                 newPd.getScope().setMatch(scopeTipoMatch);
  4757.                 newPd.getScope().setStato(StatoFunzionalita.ABILITATO);
  4758.             } else {
  4759.                 newPd.setScope(null);
  4760.             }
  4761.             
  4762.             
  4763.             if ( authzAbilitata.isToken() ) {
  4764.                 if ( newPd.getGestioneToken() == null ) {
  4765.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nessun token configurato per l'erogazione");
  4766.                 }
  4767.                 newPd.getGestioneToken().setOptions(autorizzazione_tokenOptions);
  4768.             }
  4769.             else {
  4770.                 BaseHelper.runNull( () -> newPd.getGestioneToken().setOptions(null) );
  4771.             }
  4772.             break;
  4773.         }
  4774.         case XACML_POLICY: {
  4775.             
  4776.             if(! (authz instanceof APIImplAutorizzazioneXACML)) {
  4777.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  4778.             }
  4779.             APIImplAutorizzazioneXACML authzXacml = (APIImplAutorizzazioneXACML) authz;
  4780.             
  4781.             if (authzXacml.getPolicy() == null) {
  4782.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Campo obbligatorio 'policy' non presente nell'autorizzazione indicata");
  4783.             }
  4784.             
  4785.             if (authzXacml.getRuoliFonte() == null)
  4786.                 authzXacml.setRuoliFonte(FonteEnum.QUALSIASI);
  4787.             
  4788.             final RuoloTipologia tipoRuoloFonte = Enums.ruoloTipologiaFromRest.get(authzXacml.getRuoliFonte());
  4789.             
  4790.             final String tipoAutorString =  AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString(TipoAutorizzazioneEnum.XACML_POLICY.toString(),
  4791.                     false,false,
  4792.                     false,false,
  4793.                     false,
  4794.                     "",
  4795.                     tipoRuoloFonte                                  // RuoliFonte: Qualsiasi, Registro, Esterna
  4796.                 );
  4797.             
  4798.             newPd.setAutorizzazione(tipoAutorString);
  4799.             newPd.setXacmlPolicy( evalnull( () -> new String(authzXacml.getPolicy())));             
  4800.             break;
  4801.         }
  4802.         case CUSTOM:
  4803.             
  4804.             if(! (authz instanceof APIImplAutorizzazioneCustom)) {
  4805.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  4806.             }
  4807.             APIImplAutorizzazioneCustom authzACustom = (APIImplAutorizzazioneCustom) authz;
  4808.             
  4809.             if (StringUtils.isEmpty(authzACustom.getNome())) {
  4810.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(APIImplAutorizzazioneCustom.class.getName()+": Indicare il campo obbligatorio 'nome' ");
  4811.             }
  4812.             newPd.setAutorizzazione(authzACustom.getNome());
  4813.             break;
  4814.         }   
  4815.     }



  4819.     public static final void fillPortaApplicativa(ControlloAccessiAutorizzazione body, final PortaApplicativa newPa) {
  4820.         final OneOfControlloAccessiAutorizzazioneAutorizzazione authz = body.getAutorizzazione();
  4821.         
  4822.         newPa.setXacmlPolicy(null);

  4824.         switch (authz.getTipo()) {
  4825.         case DISABILITATO: {
  4826.             
  4827.             final String tipoAutorString = TipoAutorizzazione.DISABILITATO.toString();
  4828.             newPa.setSoggetti(null);
  4829.             newPa.setRuoli(null);
  4830.             newPa.setScope(null);
  4831.             newPa.setAutorizzazione(tipoAutorString);
  4832.             break;
  4833.         }
  4834.         
  4835.         
  4836.         case ABILITATO: {
  4837.             if(! (authz instanceof APIImplAutorizzazioneAbilitata)) {
  4838.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  4839.             }
  4840.             APIImplAutorizzazioneAbilitata authzAbilitata = (APIImplAutorizzazioneAbilitata) authz;
  4841.             
  4842.             // defaults
  4843.             if ( authzAbilitata.isRuoli() && authzAbilitata.getRuoliFonte() == null ) {
  4844.                 authzAbilitata.setRuoliFonte(FonteEnum.QUALSIASI);
  4845.             }
  4846.             
  4847.             final String statoAutorizzazione = AutorizzazioneUtilities.STATO_ABILITATO;
  4848.             
  4849.             final String autorizzazioneAutenticati = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isRichiedente());
  4850.             
  4851.             final String autorizzazioneRuoli = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isRuoli());
  4852.             final RuoloTipologia tipoRuoloFonte = Enums.ruoloTipologiaFromRest.get(authzAbilitata.getRuoliFonte());
  4853.             RuoloTipoMatch tipoRuoloMatch = null;
  4854.             if(authzAbilitata.getRuoliRichiesti()!=null) {
  4855.                 tipoRuoloMatch = RuoloTipoMatch.toEnumConstant( evalnull( () -> authzAbilitata.getRuoliRichiesti().toString()) );   // Gli enum coincidono
  4856.             }
  4857.             
  4858.             final String autorizzazioneTokenAutenticati = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isTokenRichiedente());
  4859.             
  4860.             final String autorizzazioneTokenRuoli = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isTokenRuoli());
  4861.             final org.openspcoop2.core.config.constants.RuoloTipologia tipoTokenRuoloFonte = Enums.ruoloTipologiaConfigFromRest.get(authzAbilitata.getTokenRuoliFonte());
  4862.             RuoloTipoMatch tipoTokenRuoloMatch = null;
  4863.             if(authzAbilitata.getTokenRuoliRichiesti()!=null) {
  4864.                 tipoTokenRuoloMatch = RuoloTipoMatch.toEnumConstant( evalnull( () -> authzAbilitata.getTokenRuoliRichiesti().toString()) ); // Gli enum coincidono
  4865.             }
  4866.             
  4867.             final String autorizzazioneScope = ServletUtils.boolToCheckBoxStatus(authzAbilitata.isScope());
  4868.             final ScopeTipoMatch scopeTipoMatch = ScopeTipoMatch.toEnumConstant( evalnull( () -> authzAbilitata.getScopeRichiesti().toString()) );
  4869.             
  4870.             String autorizzazione_tokenOptions = null;
  4871.             if(authzAbilitata.getTokenClaims()!=null && !authzAbilitata.getTokenClaims().isEmpty()) {
  4872.                 autorizzazione_tokenOptions = String.join("\n", authzAbilitata.getTokenClaims());
  4873.             }
  4874.             
  4875.             final String tipoAutorString =  AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString(statoAutorizzazione,
  4876.                     ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati), ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli),     
  4877.                     ServletUtils.isCheckBoxEnabled(autorizzazioneTokenAutenticati), ServletUtils.isCheckBoxEnabled(autorizzazioneTokenRuoli),       
  4878.                     ServletUtils.isCheckBoxEnabled(autorizzazioneScope),        
  4879.                     autorizzazione_tokenOptions,                    // Questo è il token claims
  4880.                     tipoRuoloFonte                                  // RuoliFonte: Qualsiasi, Registro, Esterna
  4881.                 );
  4882.             
  4883.             newPa.setAutorizzazione(tipoAutorString);
  4884.             
  4885.             if ( authzAbilitata.isRuoli() ) {
  4886.                 if ( newPa.getRuoli() == null) newPa.setRuoli(new AutorizzazioneRuoli());
  4887.                 
  4888.                 newPa.getRuoli().setMatch(tipoRuoloMatch);
  4889.             } else {
  4890.                 newPa.setRuoli(null);
  4891.             }
  4892.             
  4893.             if(authzAbilitata.isTokenRichiedente() || authzAbilitata.isTokenRuoli()) {
  4894.                 newPa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  4895.                 
  4896.                 if(authzAbilitata.isTokenRichiedente()) {
  4897.                     newPa.getAutorizzazioneToken().setAutorizzazioneApplicativi(StatoFunzionalita.ABILITATO);
  4898.                 }
  4899.                 
  4900.                 if(authzAbilitata.isTokenRuoli()) {
  4901.                     newPa.getAutorizzazioneToken().setAutorizzazioneRuoli(StatoFunzionalita.ABILITATO);
  4902.                     newPa.getAutorizzazioneToken().setTipologiaRuoli(tipoTokenRuoloFonte);
  4903.                     if(newPa.getAutorizzazioneToken().getRuoli()==null) {
  4904.                         newPa.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  4905.                     }
  4906.                     newPa.getAutorizzazioneToken().getRuoli().setMatch(tipoTokenRuoloMatch);
  4907.                 }
  4908.             } else if (!authzAbilitata.isTokenRichiedente().booleanValue() && !authzAbilitata.isTokenRuoli().booleanValue() && authzAbilitata.isToken().booleanValue()) {
  4909.                 newPa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  4910.             } else {
  4911.                 newPa.setAutorizzazioneToken(null);
  4912.             }
  4913.             
  4914.             if ( authzAbilitata.isScope() ) {
  4915.                 if ( newPa.getScope() == null ) newPa.setScope(new AutorizzazioneScope());
  4916.                 
  4917.                 newPa.getScope().setMatch(scopeTipoMatch);
  4918.                 newPa.getScope().setStato(StatoFunzionalita.ABILITATO);
  4919.             } else {
  4920.                 newPa.setScope(null);
  4921.             }
  4922.             
  4923.             
  4924.             if ( authzAbilitata.isToken() ) {
  4925.                 if ( newPa.getGestioneToken() == null ) {
  4926.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nessun token configurato per l'erogazione");
  4927.                 }
  4928.                 newPa.getGestioneToken().setOptions(autorizzazione_tokenOptions);
  4929.             }
  4930.             else {
  4931.                 BaseHelper.runNull( () -> newPa.getGestioneToken().setOptions(null) );
  4932.             }
  4933.             break;
  4934.         }
  4935.         case XACML_POLICY: {
  4936.             
  4937.             if(! (authz instanceof APIImplAutorizzazioneXACML)) {
  4938.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  4939.             }
  4940.             APIImplAutorizzazioneXACML authzXacml = (APIImplAutorizzazioneXACML) authz;
  4941.             
  4942.             if (authzXacml.getPolicy() == null) {
  4943.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Campo obbligatorio 'policy' non presente nell'autorizzazione indicata");
  4944.             }
  4945.             
  4946.             if (authzXacml.getRuoliFonte() == null)
  4947.                 authzXacml.setRuoliFonte(FonteEnum.QUALSIASI);
  4948.             
  4949.             final RuoloTipologia tipoRuoloFonte = Enums.ruoloTipologiaFromRest.get(authzXacml.getRuoliFonte());
  4950.             
  4951.             final String tipoAutorString =  AutorizzazioneUtilities.convertToTipoAutorizzazioneAsString(AutorizzazioneUtilities.STATO_XACML_POLICY,
  4952.                     false,false,        
  4953.                     false,false,        
  4954.                     false,
  4955.                     "",
  4956.                     tipoRuoloFonte                                  // RuoliFonte: Qualsiasi, Registro, Esterna
  4957.                 );
  4958.             
  4959.             
  4960.             newPa.setAutorizzazione(tipoAutorString);
  4961.             newPa.setXacmlPolicy( evalnull( () -> new String(authzXacml.getPolicy())));             
  4962.             break;
  4963.         }
  4964.         case CUSTOM:
  4965.             
  4966.             if(! (authz instanceof APIImplAutorizzazioneCustom)) {
  4967.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione dell'autorizzazione '"+authz.getClass().getName()+"' non compatibile con il tipo impostato '"+authz.getTipo()+"'");
  4968.             }
  4969.             APIImplAutorizzazioneCustom authzACustom = (APIImplAutorizzazioneCustom) authz;
  4970.             
  4971.             if (StringUtils.isEmpty(authzACustom.getNome())) {
  4972.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(APIImplAutorizzazioneCustom.class.getName()+": Indicare il campo obbligatorio 'nome' ");
  4973.             }
  4974.             newPa.setAutorizzazione(authzACustom.getNome());
  4975.             break;
  4976.         }
  4977.     }
  4978.     
  4979.     



  4983.     public static final TipoAutorizzazioneEnum getTipoAutorizzazione(final String tipo_autorizzazione_pa) {
  4984.         TipoAutorizzazioneEnum tipoAuthz = null;
  4985.         
  4986.         if (TipoAutorizzazione.toEnumConstant(tipo_autorizzazione_pa) == null) {
  4987.             tipoAuthz = TipoAutorizzazioneEnum.CUSTOM;
  4988.         } else {
  4989.             String stato_auth = AutorizzazioneUtilities.convertToStato(tipo_autorizzazione_pa);
  4990.             
  4991.             if (AutorizzazioneUtilities.STATO_ABILITATO.equals(stato_auth))
  4992.                 tipoAuthz = TipoAutorizzazioneEnum.ABILITATO;
  4993.             
  4994.             else if ( AutorizzazioneUtilities.STATO_DISABILITATO.equals(stato_auth) )
  4995.                 tipoAuthz = TipoAutorizzazioneEnum.DISABILITATO;
  4996.             
  4997.             else if ( AutorizzazioneUtilities.STATO_XACML_POLICY.equals(stato_auth) )
  4998.                 tipoAuthz = TipoAutorizzazioneEnum.XACML_POLICY;
  4999.             else 
  5000.                 throw FaultCode.ERRORE_INTERNO.toException("Stato autorizzazione " + stato_auth + " sconosciuto");
  5001.         }
  5002.         return tipoAuthz;
  5003.     }



  5007.     public static final ControlloAccessiAutorizzazioneView controlloAccessiAutorizzazioneFromPA(final PortaApplicativa pa) {
  5008.         ControlloAccessiAutorizzazioneView ret = new ControlloAccessiAutorizzazioneView();
  5009.         
  5010.         TipoAutorizzazioneEnum tipoAuthz = getTipoAutorizzazione(pa.getAutorizzazione());       
  5011.     
  5012.         OneOfControlloAccessiAutorizzazioneViewAutorizzazione retAuthz = null;
  5013.         
  5014.         switch ( tipoAuthz ) {
  5015.         case ABILITATO: {
  5016.             APIImplAutorizzazioneAbilitata authzAbilitata = new APIImplAutorizzazioneAbilitata();
  5017.             authzAbilitata.setTipo(tipoAuthz);
  5018.             retAuthz = authzAbilitata;
  5019.             
  5020.             authzAbilitata.setRichiedente(TipoAutorizzazione.isAuthenticationRequired(pa.getAutorizzazione()));
  5021.             
  5022.             authzAbilitata.setRuoli( TipoAutorizzazione.isRolesRequired(pa.getAutorizzazione()) );
  5023.             if (authzAbilitata.isRuoli()) {
  5024.             
  5025.                 authzAbilitata.setRuoliRichiesti( evalnull(  () -> AllAnyEnum.fromValue( pa.getRuoli().getMatch().toString()) ) );
  5026.                 authzAbilitata.setRuoliFonte( evalnull( () -> 
  5027.                         Enums.registroTipologiaToApiFonte(  AutorizzazioneUtilities.convertToRuoloTipologia(pa.getAutorizzazione()) )
  5028.                     ));
  5029.             }
  5030.             
  5031.             if(pa.getAutorizzazioneToken()!=null) {
  5032.                 if(StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneApplicativi())) {
  5033.                     authzAbilitata.setTokenRichiedente(true);
  5034.                 }
  5035.                 
  5036.                 if(StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneRuoli())) {
  5037.                     authzAbilitata.setTokenRuoli(true);
  5038.                     
  5039.                     authzAbilitata.setTokenRuoliRichiesti( evalnull(  () -> AllAnyEnum.fromValue( pa.getAutorizzazioneToken().getRuoli().getMatch().toString()) ) );
  5040.                     if(pa.getAutorizzazioneToken().getTipologiaRuoli()!=null) {
  5041.                         switch (pa.getAutorizzazioneToken().getTipologiaRuoli()) {
  5042.                         case INTERNO:
  5043.                             authzAbilitata.setTokenRuoliFonte(FonteEnum.REGISTRO);
  5044.                             break;
  5045.                         case ESTERNO:
  5046.                             authzAbilitata.setTokenRuoliFonte(FonteEnum.ESTERNA);                       
  5047.                             break;
  5048.                         case QUALSIASI:
  5049.                             authzAbilitata.setTokenRuoliFonte(FonteEnum.QUALSIASI);
  5050.                             break;
  5051.                         }
  5052.                     }
  5053.                 }
  5054.             }
  5055.             
  5056.             authzAbilitata.setScope( pa.getScope() != null );
  5057.             authzAbilitata.setScopeRichiesti( evalnull( () -> AllAnyEnum.fromValue( pa.getScope().getMatch().getValue() )));
  5058.             
  5059.             authzAbilitata.setToken( (pa.getGestioneToken()!=null && pa.getGestioneToken().getOptions() != null) ? true : false);
  5060.             
  5061.             if(pa.getGestioneToken()!=null) {
  5062.                 String pString = pa.getGestioneToken().getOptions();
  5063.                 if(pString!=null) {
  5064.                     List<String> proprieta = new ArrayList<>();
  5065.                     String[] psplit = pString.split("\n");
  5066.                     for(String pr: psplit) {
  5067.                         proprieta.add(pr);
  5068.                     }
  5069.                     authzAbilitata.setTokenClaims(proprieta);
  5070.                 }
  5071.             }
  5072.             
  5073.             break;
  5074.         }
  5075.         case XACML_POLICY: {
  5076.             APIImplAutorizzazioneXACMLView authzXacml = new APIImplAutorizzazioneXACMLView();
  5077.             authzXacml.setTipo(tipoAuthz);
  5078.             retAuthz = authzXacml;
  5079.             
  5080.             authzXacml.setRuoliFonte( evalnull( () -> 
  5081.                     Enums.registroTipologiaToApiFonte(  AutorizzazioneUtilities.convertToRuoloTipologia(pa.getAutorizzazione()) )
  5082.                 ));

  5084.             break;
  5085.         }
  5086.         case CUSTOM: {
  5087.             APIImplAutorizzazioneCustom authzCustom = new APIImplAutorizzazioneCustom();
  5088.             authzCustom.setTipo(tipoAuthz);
  5089.             retAuthz = authzCustom;
  5090.             
  5091.             authzCustom.setNome(pa.getAutorizzazione());

  5093.             break;
  5094.         }
  5095.         case DISABILITATO: {
  5096.             APIImplAutorizzazioneDisabilitata authzDisabilitata = new APIImplAutorizzazioneDisabilitata();
  5097.             authzDisabilitata.setTipo(tipoAuthz);
  5098.             retAuthz = authzDisabilitata;
  5099.             
  5100.             break;
  5101.         }
  5102.         }
  5103.         
  5104.         ret.setAutorizzazione(retAuthz);
  5105.         return ret;
  5106.     }
  5107.     
  5108.     public static final ControlloAccessiAutorizzazioneView controlloAccessiAutorizzazioneFromPD(final PortaDelegata pd) {
  5109.         ControlloAccessiAutorizzazioneView ret = new ControlloAccessiAutorizzazioneView();
  5110.         
  5111.         TipoAutorizzazioneEnum tipoAuthz = getTipoAutorizzazione(pd.getAutorizzazione());       
  5112.     
  5113.         OneOfControlloAccessiAutorizzazioneViewAutorizzazione retAuthz = null;
  5114.         
  5115.         switch ( tipoAuthz ) {
  5116.         case ABILITATO: {
  5117.             APIImplAutorizzazioneAbilitata authzAbilitata = new APIImplAutorizzazioneAbilitata();
  5118.             authzAbilitata.setTipo(tipoAuthz);
  5119.             retAuthz = authzAbilitata;
  5120.             
  5121.             authzAbilitata.setRichiedente( TipoAutorizzazione.isAuthenticationRequired(pd.getAutorizzazione()));
  5122.             
  5123.             
  5124.             authzAbilitata.setRuoli( TipoAutorizzazione.isRolesRequired(pd.getAutorizzazione()) );
  5125.             if (authzAbilitata.isRuoli()) {
  5126.                 authzAbilitata.setRuoliRichiesti( evalnull(  () -> AllAnyEnum.fromValue( pd.getRuoli().getMatch().toString()) ) );
  5127.                 authzAbilitata.setRuoliFonte( evalnull( () -> 
  5128.                         Enums.registroTipologiaToApiFonte(  AutorizzazioneUtilities.convertToRuoloTipologia(pd.getAutorizzazione()) )
  5129.                     ));
  5130.             }
  5131.             
  5132.             if(pd.getAutorizzazioneToken()!=null) {
  5133.                 if(StatoFunzionalita.ABILITATO.equals(pd.getAutorizzazioneToken().getAutorizzazioneApplicativi())) {
  5134.                     authzAbilitata.setTokenRichiedente(true);
  5135.                 }
  5136.                 
  5137.                 if(StatoFunzionalita.ABILITATO.equals(pd.getAutorizzazioneToken().getAutorizzazioneRuoli())) {
  5138.                     authzAbilitata.setTokenRuoli(true);
  5139.                     
  5140.                     authzAbilitata.setTokenRuoliRichiesti( evalnull(  () -> AllAnyEnum.fromValue( pd.getAutorizzazioneToken().getRuoli().getMatch().toString()) ) );
  5141.                     if(pd.getAutorizzazioneToken().getTipologiaRuoli()!=null) {
  5142.                         switch (pd.getAutorizzazioneToken().getTipologiaRuoli()) {
  5143.                         case INTERNO:
  5144.                             authzAbilitata.setTokenRuoliFonte(FonteEnum.REGISTRO);
  5145.                             break;
  5146.                         case ESTERNO:
  5147.                             authzAbilitata.setTokenRuoliFonte(FonteEnum.ESTERNA);                       
  5148.                             break;
  5149.                         case QUALSIASI:
  5150.                             authzAbilitata.setTokenRuoliFonte(FonteEnum.QUALSIASI);
  5151.                             break;
  5152.                         }
  5153.                     }
  5154.                 }
  5155.             }
  5156.             
  5157.             authzAbilitata.setScope( pd.getScope() != null );
  5158.             authzAbilitata.setScopeRichiesti( evalnull( () -> AllAnyEnum.fromValue( pd.getScope().getMatch().getValue() )));
  5159.             
  5160.             authzAbilitata.setToken( (pd.getGestioneToken()!=null && pd.getGestioneToken().getOptions() != null) ? true : false);
  5161.             
  5162.             if(pd.getGestioneToken()!=null) {
  5163.                 String pString = pd.getGestioneToken().getOptions();
  5164.                 if(pString!=null) {
  5165.                     List<String> proprieta = new ArrayList<>();
  5166.                     String[] psplit = pString.split("\n");
  5167.                     for(String pr: psplit) {
  5168.                         proprieta.add(pr);
  5169.                     }
  5170.                     authzAbilitata.setTokenClaims(proprieta);
  5171.                 }
  5172.             }
  5173.                 
  5174.             break;
  5175.         }
  5176.         case XACML_POLICY: {
  5177.             APIImplAutorizzazioneXACMLView authzXacml = new APIImplAutorizzazioneXACMLView();
  5178.             authzXacml.setTipo(tipoAuthz);
  5179.             retAuthz = authzXacml;
  5180.             
  5181.             authzXacml.setRuoliFonte( evalnull( () -> 
  5182.                     Enums.registroTipologiaToApiFonte(  AutorizzazioneUtilities.convertToRuoloTipologia(pd.getAutorizzazione()) )
  5183.                 ));

  5185.             break;
  5186.         }
  5187.         case CUSTOM: {
  5188.             APIImplAutorizzazioneCustom authzCustom = new APIImplAutorizzazioneCustom();
  5189.             authzCustom.setTipo(tipoAuthz);
  5190.             retAuthz = authzCustom;
  5191.             
  5192.             authzCustom.setNome(pd.getAutorizzazione());

  5194.             break;
  5195.         }
  5196.         case DISABILITATO: {
  5197.             APIImplAutorizzazioneDisabilitata authzDisabilitata = new APIImplAutorizzazioneDisabilitata();
  5198.             authzDisabilitata.setTipo(tipoAuthz);
  5199.             retAuthz = authzDisabilitata;
  5200.             
  5201.             break;
  5202.         }
  5203.         }
  5204.         
  5205.         ret.setAutorizzazione(retAuthz);
  5206.         return ret;
  5207.     }



  5211.     public static final void fillPortaApplicativa(final ErogazioniEnv env, ControlloAccessiAutenticazione body, final PortaApplicativa newPa) throws InstantiationException, IllegalAccessException {
  5212.         final OneOfControlloAccessiAutenticazioneAutenticazione auth = body.getAutenticazione();
  5213.         final BooleanNullable autenticazioneOpzionaleNullable = getAutenticazioneOpzionale(auth); // gestisce auth se null
  5214.         
  5215.         newPa.setAutenticazioneOpzionale( evalnull( () -> Helper.boolToStatoFunzionalitaConf(autenticazioneOpzionaleNullable!=null ? autenticazioneOpzionaleNullable.getValue() : null)) );
  5216.         newPa.setAutenticazione( evalnull( () -> Enums.tipoAutenticazioneFromRest.get(auth.getTipo()).toString()) );
  5217.         
  5218.         TipoAutenticazionePrincipal autenticazionePrincipal = null;
  5219.         List<String> autenticazioneParametroList = null;
  5220.         if(auth!=null) {
  5221.             autenticazionePrincipal = getTipoAutenticazionePrincipal(auth); 
  5222.             autenticazioneParametroList = getAutenticazioneParametroList(env, auth.getTipo(), auth);
  5223.         }
  5224.         List<Proprieta> proprietaAutenticazione = env.paCore.convertToAutenticazioneProprieta(newPa.getAutenticazione(), autenticazionePrincipal, autenticazioneParametroList);
  5225.         newPa.setProprietaAutenticazioneList(proprietaAutenticazione);
  5226.         
  5227.         // Imposto l'autenticazione custom
  5228.         if ( evalnull( () -> auth.getTipo() ) == TipoAutenticazioneEnum.CUSTOM) {
  5229.             if(auth!=null && auth instanceof APIImplAutenticazioneCustom) {
  5230.                 APIImplAutenticazioneCustom authnCustom = (APIImplAutenticazioneCustom) auth;
  5231.                 newPa.setAutenticazione(authnCustom.getNome());
  5232.             }
  5233.             else {
  5234.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("La configurazione dell'autenticazione '"+(auth!=null ? auth.getTipo() : "null?")+"' non è correttamente definita (trovata configurazione '"+
  5235.                         (auth!=null ? auth.getClass().getName() : "null?")+"')"  );
  5236.             }
  5237.         }
  5238.         // Gestione Token
  5239.         final ControlloAccessiAutenticazioneToken gToken = body.getToken();
  5240.         if (gToken != null) {
  5241.             final boolean isGestioneToken = gToken.isClientId() || gToken.isEmail() || gToken.isIssuer() || gToken.isSubject() || gToken.isUsername();
  5242.             
  5243.             if (isGestioneToken) {
  5244.                 if(newPa.getGestioneToken() == null)
  5245.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("La gestione token non è abilitata per il gruppo");
  5246.                 
  5247.                 if(newPa.getGestioneToken().getAutenticazione()==null) {
  5248.                     newPa.getGestioneToken().setAutenticazione(new GestioneTokenAutenticazione());
  5249.                 }
  5250.                 
  5251.                 newPa.getGestioneToken().getAutenticazione().setIssuer(Helper.boolToStatoFunzionalitaConf(gToken.isIssuer())); 
  5252.                 newPa.getGestioneToken().getAutenticazione().setClientId(Helper.boolToStatoFunzionalitaConf(gToken.isClientId())); 
  5253.                 newPa.getGestioneToken().getAutenticazione().setSubject(Helper.boolToStatoFunzionalitaConf(gToken.isSubject())); 
  5254.                 newPa.getGestioneToken().getAutenticazione().setUsername(Helper.boolToStatoFunzionalitaConf(gToken.isUsername())); 
  5255.                 newPa.getGestioneToken().getAutenticazione().setEmail(Helper.boolToStatoFunzionalitaConf(gToken.isEmail()));    
  5256.             }
  5257.         }
  5258.         
  5259.     }
  5260.     
  5261.     
  5262.     public static final void fillPortaDelegata(final ErogazioniEnv env, ControlloAccessiAutenticazione body, final PortaDelegata newPd) {
  5263.         final OneOfControlloAccessiAutenticazioneAutenticazione auth = body.getAutenticazione();
  5264.         final BooleanNullable autenticazioneOpzionaleNullable = getAutenticazioneOpzionale(auth); // gestisce auth se null
  5265.         
  5266.         newPd.setAutenticazioneOpzionale( evalnull( () -> Helper.boolToStatoFunzionalitaConf(autenticazioneOpzionaleNullable!=null ? autenticazioneOpzionaleNullable.getValue() : null)) );
  5267.         newPd.setAutenticazione( evalnull( () -> Enums.tipoAutenticazioneFromRest.get(auth.getTipo()).toString()) );
  5268.         
  5269.         TipoAutenticazionePrincipal autenticazionePrincipal = null;
  5270.         List<String> autenticazioneParametroList = null;
  5271.         if(auth!=null) {
  5272.             autenticazionePrincipal = getTipoAutenticazionePrincipal(auth); 
  5273.             autenticazioneParametroList = getAutenticazioneParametroList(env, auth.getTipo(), auth);
  5274.         }
  5275.         List<Proprieta> proprietaAutenticazione = env.paCore.convertToAutenticazioneProprieta(newPd.getAutenticazione(), autenticazionePrincipal, autenticazioneParametroList);
  5276.         newPd.setProprietaAutenticazioneList(proprietaAutenticazione);
  5277.         
  5278.         if ( evalnull( () -> auth.getTipo() ) == TipoAutenticazioneEnum.CUSTOM) {
  5279.             if(auth!=null && auth instanceof APIImplAutenticazioneCustom) {
  5280.                 APIImplAutenticazioneCustom authnCustom = (APIImplAutenticazioneCustom) auth;
  5281.                 newPd.setAutenticazione(authnCustom.getNome());
  5282.             }
  5283.             else {
  5284.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("La configurazione dell'autenticazione '"+(auth!=null ? auth.getTipo() : "null?")+"' non è correttamente definita (trovata configurazione '"+
  5285.                         (auth!=null ? auth.getClass().getName() : "null?")+"')"  );
  5286.             }
  5287.         }
  5288.         // Gestione Token
  5289.         final ControlloAccessiAutenticazioneToken gToken = body.getToken();
  5290.         if (gToken != null) {
  5291.             final boolean isGestioneToken = gToken.isClientId() || gToken.isEmail() || gToken.isIssuer() || gToken.isSubject() || gToken.isUsername();
  5292.     
  5293.             if (isGestioneToken) {
  5294.                 if(newPd.getGestioneToken() == null)
  5295.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("La gestione token non è abilitata per il gruppo");
  5296.                 
  5297.                 if(newPd.getGestioneToken().getAutenticazione()==null) {
  5298.                     newPd.getGestioneToken().setAutenticazione(new GestioneTokenAutenticazione());
  5299.                 }
  5300.                 
  5301.                 newPd.getGestioneToken().getAutenticazione().setIssuer(Helper.boolToStatoFunzionalitaConf(gToken.isIssuer())); 
  5302.                 newPd.getGestioneToken().getAutenticazione().setClientId(Helper.boolToStatoFunzionalitaConf(gToken.isClientId())); 
  5303.                 newPd.getGestioneToken().getAutenticazione().setSubject(Helper.boolToStatoFunzionalitaConf(gToken.isSubject())); 
  5304.                 newPd.getGestioneToken().getAutenticazione().setUsername(Helper.boolToStatoFunzionalitaConf(gToken.isUsername())); 
  5305.                 newPd.getGestioneToken().getAutenticazione().setEmail(Helper.boolToStatoFunzionalitaConf(gToken.isEmail()));
  5306.             }
  5307.         }
  5308.         
  5309.     }



  5313.     public static final IDSoggetto getIdReferente(APIImpl body, final ErogazioniEnv env)
  5314.             throws DriverRegistroServiziNotFound, DriverRegistroServiziException {
  5315.         IDSoggetto idReferente = null;
  5316.          
  5317.         if( env.apcCore.isSupportatoSoggettoReferente(env.tipo_protocollo) ){
  5318.             if ( body.getApiReferente() == null )
  5319.                 body.setApiReferente(env.idSoggetto.getNome());
  5320.             
  5321.             idReferente = new IDSoggetto(env.tipo_soggetto,body.getApiReferente());
  5322.         }
  5323.     
  5324.         else {
  5325.             idReferente = env.soggettiCore.getSoggettoOperativoDefault(env.userLogin,env.tipo_protocollo);
  5326.         }
  5327.         return idReferente;
  5328.     }



  5332.     public static final GestioneCors convert(final CorsConfigurazione paConf) {
  5333.         final GestioneCors ret = new GestioneCors();
  5334.         
  5335.         if (paConf != null) {
  5336.             ret.setTipo( Enums.dualizeMap(Enums.tipoGestioneCorsFromRest).get(paConf.getTipo()));
  5337.             ret.setRidefinito(true);
  5338.             
  5339.             if ( ret.getTipo() == TipoGestioneCorsEnum.GATEWAY ) {

  5341.                 GestioneCorsAccessControl opts = new GestioneCorsAccessControl();
  5342.                 
  5343.                 opts.setAllAllowOrigins( Helper.statoFunzionalitaConfToBool( paConf.getAccessControlAllAllowOrigins() ));
  5344.                 opts.setAllAllowHeaders( Helper.statoFunzionalitaConfToBool( paConf.getAccessControlAllAllowHeaders() ));
  5345.                 opts.setAllAllowMethods( Helper.statoFunzionalitaConfToBool( paConf.getAccessControlAllAllowMethods() ));
  5346.                 opts.setAllowCredentials(  Helper.statoFunzionalitaConfToBool( paConf.getAccessControlAllowCredentials() ));
  5347.                 opts.setAllowHeaders( evalnull( () -> paConf.getAccessControlAllowHeaders().getHeaderList()) );
  5348.                 opts.setAllowMethods( evalnull( () -> 
  5349.                         paConf.getAccessControlAllowMethods().getMethodList().stream().map(HttpMethodEnum::valueOf).collect(Collectors.toList())
  5350.                         ));
  5351.                 opts.setAllowOrigins( evalnull( () -> paConf.getAccessControlAllowOrigins().getOriginList()));  
  5352.                 opts.setExposeHeaders( evalnull( () -> paConf.getAccessControlExposeHeaders().getHeaderList()) );
  5353.                 if(paConf.getAccessControlMaxAge()!=null) {
  5354.                     opts.setMaxAge( true );
  5355.                     opts.setMaxAgeSeconds(paConf.getAccessControlMaxAge());
  5356.                 }
  5357.                 
  5358.                 ret.setAccessControl(opts);
  5359.             }
  5360.             

  5362.         }
  5363.         else {
  5364.             ret.setRidefinito(false);
  5365.         }
  5366.         return ret;
  5367.     }
  5368.     
  5369.     // CONVERSIONI POLICY RAGGRUPPAMENTO
  5370.     
  5371.     public static final RateLimitingPolicyGroupBy convert( AttivazionePolicyRaggruppamento src, RateLimitingPolicyGroupBy dest ) {
  5372.         
  5373.         dest.setAzione(src.isAzione());
  5374.         
  5375.         if(src.isServizioApplicativoFruitore() || src.isFruitore() || src.isIdentificativoAutenticato()) {
  5376.             dest.setRichiedente(true);
  5377.         }
  5378.         
  5379.         if(src.getToken()!=null) {
  5380.             String [] tmp = src.getToken().split(",");
  5381.             if(tmp!=null && tmp.length>0) {
  5382.                 List<TokenClaimEnum> token = new ArrayList<>();
  5383.                 for (int i = 0; i < tmp.length; i++) {
  5384.                     TipoCredenzialeMittente tipo = null;
  5385.                     try {
  5386.                         tipo = TipoCredenzialeMittente.toEnumConstant(tmp[i], true);
  5387.                     }catch(Exception e) {
  5388.                         LoggerProperties.getLoggerCore().error(e.getMessage(),e);
  5389.                     }
  5390.                     if(tipo!=null) {
  5391.                         switch (tipo) {
  5392.                         case TOKEN_SUBJECT:
  5393.                             token.add(TokenClaimEnum.SUBJECT);
  5394.                             break;
  5395.                         case TOKEN_ISSUER:
  5396.                             token.add(TokenClaimEnum.ISSUER);
  5397.                             break;
  5398.                         case TOKEN_CLIENT_ID:
  5399.                             token.add(TokenClaimEnum.CLIENT_ID);
  5400.                             break;
  5401.                         case TOKEN_USERNAME:
  5402.                             token.add(TokenClaimEnum.USERNAME);
  5403.                             break;
  5404.                         case TOKEN_EMAIL:
  5405.                             token.add(TokenClaimEnum.EMAIL);
  5406.                             break;
  5407.                         default:
  5408.                             break;
  5409.                         }
  5410.                     }
  5411.                 }
  5412.                 dest.setToken(token);
  5413.             }
  5414.         }
  5415.         
  5416.         dest.setChiaveNome(src.getInformazioneApplicativaNome());
  5417.         dest.setChiaveTipo(
  5418.                 Enums.rateLimitingChiaveEnum.get( TipoFiltroApplicativo.toEnumConstant(src.getInformazioneApplicativaTipo()) )
  5419.             );
  5420.         
  5421.         return dest;
  5422.     }
  5423.     
  5424.     
  5425.     
  5426.     // CONVERSIONI POLICY FILTRO
  5427.     
  5428.     public static final RateLimitingPolicyFiltro  convert ( AttivazionePolicyFiltro src, RateLimitingPolicyFiltro dest ) {
  5429.         
  5430.         dest.setApplicativoFruitore( src.getServizioApplicativoFruitore() ); 
  5431.         
  5432.         if(src.getAzione()!=null && !"".equals(src.getAzione())) {
  5433.             String [] tmp = src.getAzione().split(",");
  5434.             if(tmp!=null && tmp.length>0) {
  5435.                 List<String> azione = new ArrayList<>();
  5436.                 for (int i = 0; i < tmp.length; i++) {
  5437.                     azione.add(tmp[i]);
  5438.                 }
  5439.                 dest.setAzione(azione);
  5440.             }
  5441.         }
  5442.         
  5443.         dest.setRuoloRichiedente(src.getRuoloFruitore());
  5444.         
  5445.         if(src.getTokenClaims()!=null && !"".equals(src.getTokenClaims())) {
  5446.             List<String> proprieta = new ArrayList<>();
  5447.             String[] psplit = src.getTokenClaims().split("\n");
  5448.             for(String pr: psplit) {
  5449.                 proprieta.add(pr);
  5450.             }
  5451.             dest.setTokenClaims(proprieta);
  5452.         }
  5453.         
  5454.         dest.setChiaveNome(src.getInformazioneApplicativaNome());
  5455.         dest.setChiaveTipo(
  5456.                 Enums.rateLimitingChiaveEnum.get( TipoFiltroApplicativo.toEnumConstant(src.getInformazioneApplicativaTipo()) )
  5457.             );
  5458.                 
  5459.         dest.setFiltroChiaveValore(src.getInformazioneApplicativaValore());
  5460.         
  5461.         return dest;
  5462.     }
  5463.     
  5464.     
  5465.     public static final RateLimitingPolicyFiltroErogazione  convert ( AttivazionePolicyFiltro src, RateLimitingPolicyFiltroErogazione dest ) {
  5466.         convert( src, (RateLimitingPolicyFiltro) dest);
  5467.         dest.setSoggettoFruitore(src.getNomeFruitore());
  5468.             
  5469.         return dest;
  5470.     }
  5471.     
  5472.     
  5473.     public static final RateLimitingPolicyFiltroFruizione  convert ( AttivazionePolicyFiltro src, RateLimitingPolicyFiltroFruizione dest ) {
  5474.         convert(src, (RateLimitingPolicyFiltro) dest);
  5475.         return dest;
  5476.     }
  5477.     
  5478.     
  5479.     // ATTIVAZIONE POLICY Conversion
  5480.     
  5481.     public static final RateLimitingPolicyFruizioneView convert ( AttivazionePolicy src, InfoPolicy infoPolicy, RateLimitingPolicyFruizioneView dest ) {
  5482.         
  5483.         convert( src, infoPolicy, (RateLimitingPolicyBase) dest );

  5485.         dest.setDescrizione(infoPolicy.getDescrizione());
  5486.         dest.setNome( PolicyUtilities.getNomeActivePolicy(src.getAlias(), src.getIdActivePolicy()));
  5487.                 
  5488.         dest.setRaggruppamento(
  5489.                 convert( src.getGroupBy(), new RateLimitingPolicyGroupBy() )
  5490.             );
  5491.      
  5492.         
  5493.         dest.setFiltro(
  5494.                 convert( src.getFiltro(), new RateLimitingPolicyFiltroFruizione() )
  5495.             );
  5496.         
  5497.         return dest;
  5498.     }

  5500.     
  5501.     
  5502.     public static final RateLimitingPolicyErogazioneView convert ( AttivazionePolicy src, InfoPolicy infoPolicy, RateLimitingPolicyErogazioneView dest ) {
  5503.         
  5504.         convert( src, infoPolicy, (RateLimitingPolicyBase) dest );

  5506.         dest.setDescrizione(infoPolicy.getDescrizione());
  5507.         dest.setNome( PolicyUtilities.getNomeActivePolicy(src.getAlias(), src.getIdActivePolicy()));
  5508.         
  5509.         dest.setRaggruppamento(
  5510.                 convert( src.getGroupBy(), new RateLimitingPolicyGroupBy() )
  5511.             );
  5512.      
  5513.         
  5514.         dest.setFiltro(
  5515.                 convert( src.getFiltro(), new RateLimitingPolicyFiltroErogazione() )
  5516.             );
  5517.         
  5518.         return dest;
  5519.     }
  5520.     
  5521.     
  5522.     public static final RateLimitingPolicyBase convert (AttivazionePolicy src, InfoPolicy infoPolicy, RateLimitingPolicyBase dest ) {
  5523.     
  5524.         dest.setNome(src.getAlias());
  5525.         
  5526.         if ( src.isWarningOnly() )
  5527.             dest.setStato( StatoFunzionalitaConWarningEnum.WARNINGONLY );
  5528.         
  5529.         if ( src.isEnabled() )
  5530.             dest.setStato(StatoFunzionalitaConWarningEnum.ABILITATO );
  5531.         else
  5532.             dest.setStato(StatoFunzionalitaConWarningEnum.DISABILITATO );
  5533.         
  5534.         boolean dimensioneMessaggio = false;
  5535.         
  5536.         if(dest instanceof RateLimitingPolicyBaseConIdentificazione) {
  5537.             RateLimitingPolicyBaseConIdentificazione destIdentificazione = (RateLimitingPolicyBaseConIdentificazione) dest;
  5538.             
  5539.             if(infoPolicy.isBuiltIn()) {
  5540.                 RateLimitingPolicyCriteri criteri = new RateLimitingPolicyCriteri();
  5541.                 criteri.setIdentificazione(RateLimitingIdentificazionePolicyEnum.CRITERI);
  5542.                 boolean intervallo = true;
  5543.                 switch (infoPolicy.getTipoRisorsa()) {
  5544.                 case NUMERO_RICHIESTE:
  5545.                     if(infoPolicy.isCheckRichiesteSimultanee()) {
  5546.                         criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_RICHIESTE_SIMULTANEE);
  5547.                         intervallo = false;
  5548.                     }
  5549.                     else {
  5550.                         criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_RICHIESTE);
  5551.                     }
  5552.                     break;
  5553.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  5554.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_RICHIESTE_OK);
  5555.                     break;
  5556.                 case NUMERO_RICHIESTE_FALLITE:
  5557.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_RICHIESTE_FALLITE);
  5558.                     break;
  5559.                 case NUMERO_FAULT_APPLICATIVI:
  5560.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_FAULT_APPLICATIVI);
  5561.                     break;
  5562.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  5563.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_RICHIESTE_FALLITE_O_FAULT_APPLICATIVI);
  5564.                     break;
  5565.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  5566.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.NUMERO_RICHIESTE_OK_O_FAULT_APPLICATIVI);
  5567.                     break;
  5568.                 case DIMENSIONE_MASSIMA_MESSAGGIO:
  5569.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.DIMENSIONE_MASSIMA);
  5570.                     dimensioneMessaggio = true;
  5571.                     break;
  5572.                 case OCCUPAZIONE_BANDA:
  5573.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.OCCUPAZIONE_BANDA);
  5574.                     break;
  5575.                 case TEMPO_MEDIO_RISPOSTA:
  5576.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.TEMPO_MEDIO_RISPOSTA);
  5577.                     break;
  5578.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  5579.                     criteri.setMetrica(RateLimitingCriteriMetricaEnum.TEMPO_COMPLESSIVO_RISPOSTA);
  5580.                     break;
  5581.                 }
  5582.                 if(intervallo) {
  5583.                     switch (infoPolicy.getIntervalloUtilizzaRisorseRealtimeTipoPeriodo()) {
  5584.                     case MINUTI:
  5585.                         criteri.setIntervallo(RateLimitingCriteriIntervalloEnum.MINUTI);
  5586.                         break;
  5587.                     case ORARIO:
  5588.                         criteri.setIntervallo(RateLimitingCriteriIntervalloEnum.ORARIO);
  5589.                         break;
  5590.                     case GIORNALIERO:
  5591.                         criteri.setIntervallo(RateLimitingCriteriIntervalloEnum.GIORNALIERO);
  5592.                         break;
  5593.                     default:
  5594.                         break;
  5595.                     }
  5596.                 }
  5597.                 criteri.setCongestione(infoPolicy.isControlloCongestione());
  5598.                 criteri.setDegrado(infoPolicy.isDegradoPrestazione());
  5599.                 destIdentificazione.setConfigurazione(criteri);
  5600.             }
  5601.             else {
  5602.                 RateLimitingPolicyIdentificativo id = new RateLimitingPolicyIdentificativo();
  5603.                 id.setIdentificazione(RateLimitingIdentificazionePolicyEnum.POLICY);
  5604.                 id.setPolicy(infoPolicy.getIdPolicy());
  5605.                 
  5606.                 if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())) {
  5607.                     dimensioneMessaggio = true;
  5608.                 }
  5609.                 
  5610.                 destIdentificazione.setConfigurazione(id);
  5611.             }
  5612.         }

  5614.         
  5615.         
  5616.         dest.setSogliaRidefinita(src.isRidefinisci());
  5617.         
  5618.         if ( src.isRidefinisci()) {
  5619.             if(dimensioneMessaggio) {
  5620.                 dest.setSogliaDimensioneRichiesta(src.getValore2().intValue());
  5621.                 dest.setSogliaDimensioneRisposta(src.getValore().intValue());
  5622.             }
  5623.             else {
  5624.                 dest.setSogliaValore(src.getValore().intValue());
  5625.             }
  5626.         }
  5627.         else {
  5628.             if(dimensioneMessaggio) {
  5629.                 dest.setSogliaDimensioneRichiesta(infoPolicy.getValore2().intValue());
  5630.                 dest.setSogliaDimensioneRisposta(infoPolicy.getValore().intValue());
  5631.             }
  5632.             else {
  5633.                 dest.setSogliaValore(infoPolicy.getValore().intValue());
  5634.             }
  5635.         }
  5636.         
  5637.         
  5638.         return dest;
  5639.             
  5640.     }


  5643.     public static final void checkAzioniAdd( List<String> toAdd, List<String> occupate, List<String> presenti ) {
  5644.         
  5645.         for ( String azione : toAdd ) {
  5646.             
  5647.             if( occupate.contains(azione) ) {
  5648.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_GIA_PRESENTE));           
  5649.             }
  5650.             
  5651.             if( !presenti.contains(azione) ) {
  5652.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Azione " + azione + " non presente fra le azioni dell'accordo");
  5653.             }
  5654.         }
  5655.         
  5656.     }


  5659.     public static final String getDataElementModalita(RateLimitingIdentificazionePolicyEnum identificazione) {
  5660.         switch (identificazione) {
  5661.         case POLICY:
  5662.             return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CUSTOM;
  5663.         case CRITERI:
  5664.             return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_BUILT_IN;
  5665.         }
  5666.         return null;
  5667.     }
  5668.     public static final String getDataElementModalita(boolean builtIt) {
  5669.         return builtIt ? getDataElementModalita(RateLimitingIdentificazionePolicyEnum.CRITERI) : getDataElementModalita(RateLimitingIdentificazionePolicyEnum.POLICY);
  5670.     }
  5671.     
  5672.     public static final String getIdPolicy(RateLimitingPolicyBaseConIdentificazione body, ConfigurazioneCore confCore, ConfigurazioneHelper confHelper) throws Exception {
  5673.         
  5674.         String idPolicy = null;
  5675.         switch (body.getConfigurazione().getIdentificazione()) {
  5676.         case POLICY:
  5677.             RateLimitingPolicyIdentificativo identificativo = new RateLimitingPolicyIdentificativo();
  5678.             identificativo = BaseHelper.deserialize(body.getConfigurazione(), RateLimitingPolicyIdentificativo.class);
  5679.             idPolicy = identificativo.getPolicy();
  5680.             break;
  5681.         case CRITERI:
  5682.             RateLimitingPolicyCriteri criteri = new RateLimitingPolicyCriteri();
  5683.             criteri = BaseHelper.deserialize(body.getConfigurazione(), RateLimitingPolicyCriteri.class);
  5684.             
  5685.             String modalitaRisorsa = getDataElementModalitaRisorsa(criteri.getMetrica());
  5686.             boolean modalitaSimultaneeEnabled = confHelper.isTipoRisorsaNumeroRichiesteSimultanee(modalitaRisorsa);
  5687.             String modalitaEsiti = null;
  5688.             String modalitaIntervallo = null;
  5689.             if(criteri.getIntervallo()!=null) {
  5690.                 modalitaIntervallo = getDataElementModalitaIntervallo(criteri.getIntervallo());
  5691.             }
  5692.             boolean modalitaCongestioneEnabled = criteri.isCongestione()!=null ? criteri.isCongestione() : false;
  5693.             boolean modalitaDegradoEnabled = criteri.isDegrado()!=null ? criteri.isDegrado() : false;
  5694.             boolean modalitaErrorRateEnabled = false;
  5695.             
  5696.             List<InfoPolicy> infoPolicies = confCore.infoPolicyList(true);
  5697.             List<InfoPolicy> idPoliciesSoddisfanoCriteri = new ArrayList<>();
  5698.             confHelper.findPolicyBuiltIn(infoPolicies, idPoliciesSoddisfanoCriteri, 
  5699.                     modalitaRisorsa, modalitaEsiti, modalitaSimultaneeEnabled, modalitaIntervallo, 
  5700.                     modalitaCongestioneEnabled, modalitaDegradoEnabled, modalitaErrorRateEnabled);
  5701.             if(idPoliciesSoddisfanoCriteri.size()>0) {
  5702.                 idPolicy = idPoliciesSoddisfanoCriteri.get(0).getIdPolicy();
  5703.             }
  5704.             break;
  5705.         }
  5706.         
  5707.         return idPolicy;
  5708.     }
  5709.     
  5710.     public static String getDataElementModalitaRisorsa(RateLimitingCriteriMetricaEnum risorsa) {
  5711.         TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = null;
  5712.         switch (risorsa) {
  5713.         case NUMERO_RICHIESTE:
  5714.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE;
  5715.             break;
  5716.         case NUMERO_RICHIESTE_SIMULTANEE:
  5717.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_SIMULTANEE;
  5718.             break;
  5719.         case NUMERO_RICHIESTE_OK:
  5720.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO;
  5721.             break;
  5722.         case NUMERO_RICHIESTE_FALLITE:
  5723.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_FALLITE;
  5724.             break;
  5725.         case NUMERO_FAULT_APPLICATIVI:
  5726.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_FAULT_APPLICATIVI;
  5727.             break;
  5728.         case NUMERO_RICHIESTE_FALLITE_O_FAULT_APPLICATIVI:
  5729.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI;
  5730.             break;
  5731.         case NUMERO_RICHIESTE_OK_O_FAULT_APPLICATIVI:
  5732.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI;
  5733.             break;
  5734.         case DIMENSIONE_MASSIMA:
  5735.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.DIMENSIONE_MASSIMA_MESSAGGIO;
  5736.             break;
  5737.         case OCCUPAZIONE_BANDA:
  5738.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.OCCUPAZIONE_BANDA;
  5739.             break;
  5740.         case TEMPO_MEDIO_RISPOSTA:
  5741.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.TEMPO_MEDIO_RISPOSTA;
  5742.             break;
  5743.         case TEMPO_COMPLESSIVO_RISPOSTA:
  5744.             tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.TEMPO_COMPLESSIVO_RISPOSTA;
  5745.             break;
  5746.         }
  5747.         return tipoRisorsaPolicyAttiva!=null ? tipoRisorsaPolicyAttiva.getValue() : null;
  5748.     }
  5749.     private static String getDataElementModalitaIntervallo(RateLimitingCriteriIntervalloEnum intervallo) {
  5750.         String modalitaRisorsaEsiti = null;
  5751.         switch (intervallo) {
  5752.         case MINUTI:
  5753.             modalitaRisorsaEsiti = TipoPeriodoRealtime.MINUTI.getValue();
  5754.             break;
  5755.         case ORARIO:
  5756.             modalitaRisorsaEsiti = TipoPeriodoRealtime.ORARIO.getValue();
  5757.             break;
  5758.         case GIORNALIERO:
  5759.             modalitaRisorsaEsiti = TipoPeriodoRealtime.GIORNALIERO.getValue();
  5760.             break;
  5761.         }
  5762.         return modalitaRisorsaEsiti;
  5763.     }
  5764.     
  5765.     
  5766.     public static final void override(TipoRisorsa tipoRisorsa, String idPolicy, RateLimitingPolicyErogazione body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5767.         if (body == null) return;

  5769.         override (tipoRisorsa, (RateLimitingPolicyErogazione) body, protocollo, idPropietarioSa, wrap );
  5770.         
  5771.         wrap.overrideParameter(
  5772.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID, 
  5773.                 idPolicy    
  5774.             );      
  5775.     }
  5776.     

  5778.     public static final void override(TipoRisorsa tipoRisorsa, String idPolicy, RateLimitingPolicyFruizione body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5779.         if (body == null) return;

  5781.         override (tipoRisorsa, (RateLimitingPolicyFruizione) body, protocollo, idPropietarioSa, wrap );
  5782.         
  5783.         wrap.overrideParameter(
  5784.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID, 
  5785.                 idPolicy
  5786.             );
  5787.     }
  5788.     
  5789.     public static final void override( RateLimitingPolicyFiltro body, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5790.         if (body == null) return;
  5791.         
  5792.         if(body.getAzione()!=null && !body.getAzione().isEmpty()) {
  5793.         
  5794.             wrap.overrideParameterValues(
  5795.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE,
  5796.                     body.getAzione().toArray(new String[1])
  5797.                 );
  5798.         
  5799.         }
  5800.         
  5801.         wrap.overrideParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE, body.getApplicativoFruitore());
  5802.         
  5803.         wrap.overrideParameter(
  5804.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE,
  5805.                 evalnull( () -> body.getRuoloRichiedente() )  
  5806.             );
  5807.         
  5808.         String tokenClaims = null;
  5809.         if(body.getTokenClaims()!=null && !body.getTokenClaims().isEmpty()) {
  5810.             tokenClaims = String.join("\n", body.getTokenClaims());
  5811.         }
  5812.         if(tokenClaims!=null) {
  5813.             wrap.overrideParameter(
  5814.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS,
  5815.                     tokenClaims   
  5816.                 );
  5817.         }
  5818.         
  5819.         
  5820.         wrap.overrideParameter(
  5821.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED,
  5822.                 evalnull( () -> ServletUtils.boolToCheckBoxStatus( body.getChiaveTipo() != null ))  // TOWAIT: mailandrea, non ho in rest un valore per la checkbox isFiltroAbilitato, quindi deduco il valore della checkbox così 
  5823.             );
  5824.         
  5825.         wrap.overrideParameter(
  5826.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO,
  5827.                 evalnull( () -> Enums.tipoFiltroApplicativo.get( body.getChiaveTipo() ).toString()) 
  5828.             );
  5829.         
  5830.         wrap.overrideParameter(
  5831.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_NOME,
  5832.                 evalnull( () -> body.getChiaveNome() )  
  5833.             );
  5834.         
  5835.         wrap.overrideParameter(
  5836.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE,
  5837.                 evalnull( () -> body.getFiltroChiaveValore() ) 
  5838.             );  
  5839.     }
  5840.     
  5841.     public static final void override(  RateLimitingPolicyGroupBy body,  IDSoggetto idPropietarioSa, HttpRequestWrapper wrap )
  5842.     {
  5843.         if (body == null) return;

  5845.     
  5846.         wrap.overrideParameter(
  5847.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED,
  5848.                 body != null 
  5849.                     ?  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO
  5850.                     :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_DISABILITATO
  5851.             );
  5852.         
  5853.         wrap.overrideParameter(
  5854.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_AZIONE,
  5855.                 evalnull(  () -> ServletUtils.boolToCheckBoxStatus( body.isAzione() ) )
  5856.             );  
  5857.         
  5858.         wrap.overrideParameter(
  5859.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RICHIEDENTE,
  5860.                 evalnull(  () -> ServletUtils.boolToCheckBoxStatus( body.isRichiedente() ) )
  5861.             );
  5862.         
  5863.         if(body.getToken()!=null && !body.getToken().isEmpty()) {
  5864.             
  5865.             wrap.overrideParameter(
  5866.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN,
  5867.                     evalnull(  () -> ServletUtils.boolToCheckBoxStatus( true ) )
  5868.                 );
  5869.             
  5870.             List<String> values = new ArrayList<>();
  5871.             for (TokenClaimEnum tokenClaim : body.getToken()) {
  5872.                 switch (tokenClaim) {
  5873.                 case SUBJECT:
  5874.                     values.add(TipoCredenzialeMittente.TOKEN_SUBJECT.getRawValue());
  5875.                     break;
  5876.                 case ISSUER:
  5877.                     values.add(TipoCredenzialeMittente.TOKEN_ISSUER.getRawValue());
  5878.                     break;
  5879.                 case CLIENT_ID:
  5880.                     values.add(TipoCredenzialeMittente.TOKEN_CLIENT_ID.getRawValue());
  5881.                     break;
  5882.                 case USERNAME:
  5883.                     values.add(TipoCredenzialeMittente.TOKEN_USERNAME.getRawValue());
  5884.                     break;
  5885.                 case EMAIL:
  5886.                     values.add(TipoCredenzialeMittente.TOKEN_EMAIL.getRawValue());
  5887.                     break;
  5888.                 default:
  5889.                     break;
  5890.                 }
  5891.             }
  5892.             if(!values.isEmpty()) {
  5893.                 wrap.overrideParameterValues(
  5894.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN_CLAIMS,
  5895.                         values.toArray(new String[1])
  5896.                     );
  5897.             }
  5898.         }       
  5899.         
  5900.         wrap.overrideParameter(
  5901.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED,
  5902.                 evalnull(  () -> ServletUtils.boolToCheckBoxStatus( body.getChiaveTipo() != null ) )  
  5903.             );
  5904.         
  5905.         wrap.overrideParameter(
  5906.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO,
  5907.                 evalnull( () -> Enums.tipoFiltroApplicativo.get(body.getChiaveTipo()).toString() )
  5908.             );
  5909.         
  5910.         wrap.overrideParameter(
  5911.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_NOME,
  5912.                 evalnull( () -> body.getChiaveNome() )
  5913.             ); 
  5914.     }
  5915.     
  5916.     public static final void override(TipoRisorsa tipoRisorsa, RateLimitingPolicyErogazioneUpdate body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5917.         if (body == null) return;

  5919.         override(tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  5920.         
  5921.         wrap.overrideParameter(
  5922.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  5923.                 RuoloPolicy.APPLICATIVA.toString() 
  5924.         );
  5925.         
  5926.         // Campi in più rispetto al padre:
  5927.         RateLimitingPolicyFiltroErogazione filtro = body.getFiltro();
  5928.         override( filtro, idPropietarioSa, wrap );
  5929.         
  5930.         if(filtro!=null) {
  5931.             final String filtroFruitore = evalnull(() -> filtro.getSoggettoFruitore()) != null   
  5932.                     ? new IDSoggetto(idPropietarioSa.getTipo(), filtro.getSoggettoFruitore()).toString()
  5933.                     : null;
  5934.             
  5935.             wrap.overrideParameter(
  5936.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE,
  5937.                     filtroFruitore 
  5938.                 );
  5939.         }
  5940.         
  5941.         RateLimitingPolicyGroupBy groupCriteria = body.getRaggruppamento();
  5942.         override( groupCriteria, idPropietarioSa, wrap );

  5944.     }
  5945.     public static final void override(TipoRisorsa tipoRisorsa, RateLimitingPolicyErogazione body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5946.         if (body == null) return;

  5948.         override(tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  5949.         
  5950.         wrap.overrideParameter(
  5951.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  5952.                 RuoloPolicy.APPLICATIVA.toString() 
  5953.         );
  5954.         
  5955.         // Campi in più rispetto al padre:
  5956.         RateLimitingPolicyFiltroErogazione filtro = body.getFiltro();
  5957.         override( filtro, idPropietarioSa, wrap );
  5958.         
  5959.         if(filtro!=null) {
  5960.             final String filtroFruitore = evalnull(() -> filtro.getSoggettoFruitore()) != null   
  5961.                     ? new IDSoggetto(idPropietarioSa.getTipo(), filtro.getSoggettoFruitore()).toString()
  5962.                     : null;
  5963.             
  5964.             wrap.overrideParameter(
  5965.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE,
  5966.                     filtroFruitore 
  5967.                 );
  5968.         }
  5969.         
  5970.         RateLimitingPolicyGroupBy groupCriteria = body.getRaggruppamento();
  5971.         override( groupCriteria, idPropietarioSa, wrap );

  5973.     }
  5974.     
  5975.     
  5976.     
  5977.     public static final void override (TipoRisorsa tipoRisorsa,  RateLimitingPolicyFruizioneUpdate body,  String protocollo, IDSoggetto idPropietarioSa,  HttpRequestWrapper wrap ) {   // Questa è in comune alla update.
  5978.         if (body == null) return;

  5980.         override ( tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  5981.         override ( body.getFiltro(), idPropietarioSa, wrap );
  5982.         override ( body.getRaggruppamento() , idPropietarioSa, wrap );
  5983.         
  5984.         wrap.overrideParameter(
  5985.             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  5986.             RuoloPolicy.DELEGATA.toString() 
  5987.         );
  5988.     }
  5989.     public static final void override (TipoRisorsa tipoRisorsa,  RateLimitingPolicyFruizione body,  String protocollo, IDSoggetto idPropietarioSa,  HttpRequestWrapper wrap ) { // Questa è in comune alla update.
  5990.         if (body == null) return;

  5992.         override ( tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  5993.         override ( body.getFiltro(), idPropietarioSa, wrap );
  5994.         override ( body.getRaggruppamento() , idPropietarioSa, wrap );
  5995.         
  5996.         wrap.overrideParameter(
  5997.             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  5998.             RuoloPolicy.DELEGATA.toString() 
  5999.         );
  6000.         
  6001.     }
  6002.         
  6003.     public static final void override (TipoRisorsa tipoRisorsa, RateLimitingPolicyBase body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) { // Questa è in comune alla update.      
  6004.         if (body == null) return;

  6006.         wrap.overrideParameter(
  6007.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS,
  6008.                 body.getNome()
  6009.             );      
  6010.         
  6011.         wrap.overrideParameter(
  6012.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ENABLED,
  6013.                 body.getStato().toString()
  6014.                 );
  6015.         
  6016.         wrap.overrideParameter(
  6017.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_RIDEFINISCI,
  6018.                 ServletUtils.boolToCheckBoxStatus( body.isSogliaRidefinita() )
  6019.             );
  6020.         
  6021.         
  6022.         if(body.isSogliaRidefinita()) {
  6023.             if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  6024.                 
  6025.                 if(body.getSogliaDimensioneRichiesta()==null) {
  6026.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Soglia relativa alla dimensione della richiesta non fornita");
  6027.                 }
  6028.                 if(body.getSogliaDimensioneRisposta()==null) {
  6029.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Soglia relativa alla dimensione della risposta non fornita");
  6030.                 }
  6031.                 if(body.getSogliaValore()!=null) {
  6032.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Valore di Soglia non utilizzabile con una policy di tipo '"+RateLimitingCriteriMetricaEnum.DIMENSIONE_MASSIMA.toString()+"'");
  6033.                 }
  6034.                 
  6035.                 wrap.overrideParameter(
  6036.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE_2, 
  6037.                         evalnull( () -> body.getSogliaDimensioneRichiesta().toString() )
  6038.                     );
  6039.                 
  6040.                 wrap.overrideParameter(
  6041.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE, 
  6042.                         evalnull( () -> body.getSogliaDimensioneRisposta().toString() )
  6043.                     );
  6044.                 
  6045.             }
  6046.             else {
  6047.             
  6048.                 if(body.getSogliaDimensioneRichiesta()!=null) {
  6049.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Soglia relativa alla dimensione della richiesta non utilizzabile con una policy di tipo diverso da '"+RateLimitingCriteriMetricaEnum.DIMENSIONE_MASSIMA.toString()+"'");
  6050.                 }
  6051.                 if(body.getSogliaDimensioneRisposta()!=null) {
  6052.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Soglia relativa alla dimensione della risposta non utilizzabile con una policy di tipo diverso da '"+RateLimitingCriteriMetricaEnum.DIMENSIONE_MASSIMA.toString()+"'");
  6053.                 }
  6054.                 if(body.getSogliaValore()==null) {
  6055.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Valore di Soglia non fornito");
  6056.                 }
  6057.                 
  6058.                 wrap.overrideParameter(
  6059.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE, 
  6060.                         evalnull( () -> body.getSogliaValore().toString() )
  6061.                     );
  6062.                 
  6063.             }
  6064.         }
  6065.         
  6066.         wrap.overrideParameter(
  6067.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED,
  6068.                 StatoFunzionalita.ABILITATO.toString() 
  6069.             );
  6070.         
  6071.         wrap.overrideParameter(
  6072.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO,
  6073.                 protocollo 
  6074.             );
  6075.     }


  6078.     public static final boolean correlazioneApplicativaRichiestaCheckData(
  6079.             TipoOperazione tipoOp,
  6080.             HttpRequestWrapper wrap,
  6081.             ConsoleHelper paHelper,
  6082.             boolean isDelegata,
  6083.             CorrelazioneApplicativaRichiesta body,
  6084.             Long idPorta,
  6085.             Long idCorrelazione,
  6086.             org.openspcoop2.message.constants.ServiceBinding serviceBinding
  6087.             
  6088.         ) throws Exception {
  6089.         
  6090.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID, idPorta.toString() );
  6091.         
  6092.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ELEMENTO_XML, body.getElemento() );        // Campo elemento oppure "Qualsiasi"
  6093.         
  6094.         wrap.overrideParameter( 
  6095.                 CostantiControlStation.PARAMETRO_MODE_CORRELAZIONE_APPLICATIVA, 
  6096.                 CorrelazioneApplicativaRichiestaIdentificazione.valueOf(body.getIdentificazioneTipo().name()).toString()
  6097.             );
  6098.         
  6099.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_PATTERN, body.getIdentificazione() );
  6100.         
  6101.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID_CORRELAZIONE, evalnull( () -> idCorrelazione.toString() ) );                    // Questo va impostato nella update.
  6102.         
  6103.         return paHelper.correlazioneApplicativaRichiestaCheckData(tipoOp,isDelegata,
  6104.                 serviceBinding);
  6105.         
  6106.     }
  6107.     
  6108.     
  6109.     public static final CorrelazioneApplicativaElemento convert(CorrelazioneApplicativaRichiesta body) {
  6110.         
  6111.         CorrelazioneApplicativaElemento cae = new CorrelazioneApplicativaElemento();
  6112.         cae.setNome(body.getElemento());
  6113.         cae.setIdentificazione(CorrelazioneApplicativaRichiestaIdentificazione.valueOf(body.getIdentificazioneTipo().name()));
  6114.         
  6115.         if ( body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.URL_BASED 
  6116.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.HEADER_BASED 
  6117.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.CONTENT_BASED
  6118.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.TEMPLATE
  6119.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.FREEMARKER_TEMPLATE
  6120.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.VELOCITY_TEMPLATE) {
  6121.             
  6122.             cae.setPattern(body.getIdentificazione());
  6123.         }
  6124.         
  6125.         if ( body.getIdentificazioneTipo() != CorrelazioneApplicativaRichiestaEnum.DISABILITATO ) {
  6126.             
  6127.             cae.setIdentificazioneFallita(body.isGenerazioneErroreIdentificazioneFallita()
  6128.                     ? CorrelazioneApplicativaGestioneIdentificazioneFallita.BLOCCA 
  6129.                     : CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6130.                 );
  6131.         }
  6132.         return cae;
  6133.     }
  6134.     
  6135.         
  6136.     public static final CorrelazioneApplicativaRispostaElemento convert(CorrelazioneApplicativaRisposta body) {

  6138.         CorrelazioneApplicativaRispostaElemento cae = new CorrelazioneApplicativaRispostaElemento();
  6139.         cae.setNome(body.getElemento());
  6140.         cae.setIdentificazione(CorrelazioneApplicativaRispostaIdentificazione.valueOf(body.getIdentificazioneTipo().name()));
  6141.         
  6142.         if (     body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.HEADER_BASED 
  6143.             ||   body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.CONTENT_BASED
  6144.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.TEMPLATE
  6145.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.FREEMARKER_TEMPLATE
  6146.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.VELOCITY_TEMPLATE  ) {
  6147.             
  6148.             cae.setPattern(body.getIdentificazione());
  6149.         }
  6150.         
  6151.         if ( body.getIdentificazioneTipo() != CorrelazioneApplicativaRispostaEnum.DISABILITATO ) {
  6152.             
  6153.             cae.setIdentificazioneFallita(body.isGenerazioneErroreIdentificazioneFallita()
  6154.                     ? CorrelazioneApplicativaGestioneIdentificazioneFallita.BLOCCA 
  6155.                     : CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6156.                 );
  6157.         }
  6158.         return cae;
  6159.     }
  6160.     
  6161.     
  6162.     public static final boolean correlazioneApplicativaRispostaCheckData(
  6163.             TipoOperazione tipoOp,
  6164.             HttpRequestWrapper wrap,
  6165.             ConsoleHelper paHelper,
  6166.             boolean isDelegata,
  6167.             CorrelazioneApplicativaRisposta body,
  6168.             Long idPorta,
  6169.             Long idCorrelazione,
  6170.             org.openspcoop2.message.constants.ServiceBinding serviceBinding
  6171.         ) throws Exception {
  6172.         
  6173.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID, idPorta.toString() );
  6174.         
  6175.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ELEMENTO_XML, body.getElemento() );        // Campo elemento oppure "Qualsiasi"
  6176.         
  6177.         wrap.overrideParameter( 
  6178.                 CostantiControlStation.PARAMETRO_MODE_CORRELAZIONE_APPLICATIVA, 
  6179.                 CorrelazioneApplicativaRichiestaIdentificazione.valueOf(body.getIdentificazioneTipo().name()).toString()
  6180.             );
  6181.         
  6182.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_PATTERN, body.getIdentificazione() );
  6183.         
  6184.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID_CORRELAZIONE, evalnull( () -> idCorrelazione.toString() ));
  6185.     
  6186.         
  6187.         return paHelper.correlazioneApplicativaRichiestaCheckData(TipoOperazione.ADD,isDelegata,
  6188.                 serviceBinding);
  6189.         
  6190.     }



  6194.     public static final CorrelazioneApplicativaRichiesta convert( CorrelazioneApplicativaElemento  src) {
  6195.         CorrelazioneApplicativaRichiesta ret = new CorrelazioneApplicativaRichiesta();
  6196.         
  6197.         ret.setElemento( StringUtils.isEmpty(src.getNome())
  6198.                 ? "*"
  6199.                 : src.getNome()
  6200.             );
  6201.         
  6202.         ret.setGenerazioneErroreIdentificazioneFallita(src.getIdentificazioneFallita() == CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6203.                 ? false
  6204.                 : true
  6205.             );
  6206.         
  6207.         ret.setIdentificazione(src.getPattern());
  6208.         ret.setIdentificazioneTipo(CorrelazioneApplicativaRichiestaEnum.valueOf(src.getIdentificazione().name()));
  6209.         
  6210.         return ret;
  6211.     }
  6212.     
  6213.     
  6214.     public static final CorrelazioneApplicativaRisposta convert( CorrelazioneApplicativaRispostaElemento  src) {
  6215.         CorrelazioneApplicativaRisposta ret = new CorrelazioneApplicativaRisposta();
  6216.         
  6217.         ret.setElemento( StringUtils.isEmpty(src.getNome())
  6218.                 ? "*"
  6219.                 : src.getNome()
  6220.             );
  6221.         
  6222.         ret.setGenerazioneErroreIdentificazioneFallita(src.getIdentificazioneFallita() == CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6223.                 ? false
  6224.                 : true
  6225.             );
  6226.         
  6227.         ret.setIdentificazione(src.getPattern());
  6228.         ret.setIdentificazioneTipo(CorrelazioneApplicativaRispostaEnum.valueOf(src.getIdentificazione().name()));
  6229.         
  6230.         return ret;
  6231.     }
  6232.     
  6233.     public static final boolean isDumpConfigurazioneAbilitato(DumpConfigurazione configurazione, boolean isRisposta) {
  6234.         boolean abilitato = false;
  6235.         
  6236.         if(configurazione == null)
  6237.             return false;
  6238.         
  6239.         if(isRisposta) {
  6240.             DumpConfigurazioneRegola rispostaIngresso = configurazione.getRispostaIngresso();
  6241.             
  6242.             if(rispostaIngresso != null) {
  6243.                 if(rispostaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6244.                     return true;
  6245.                 
  6246.                 if(rispostaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  6247.                     return true;
  6248.                 
  6249.                 if(rispostaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6250.                     return true;
  6251.             }
  6252.             
  6253.             DumpConfigurazioneRegola rispostaUscita = configurazione.getRispostaUscita();
  6254.             
  6255.             if(rispostaUscita != null) {
  6256.                 if(rispostaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6257.                     return true;
  6258.                 
  6259.                 if(rispostaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  6260.                     return true;
  6261.                 
  6262.                 if(rispostaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6263.                     return true;
  6264.             }
  6265.         } else {
  6266.             DumpConfigurazioneRegola richiestaIngresso = configurazione.getRichiestaIngresso();
  6267.             
  6268.             if(richiestaIngresso != null) {
  6269.                 if(richiestaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6270.                     return true;
  6271.                 
  6272.                 if(richiestaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  6273.                     return true;
  6274.                 
  6275.                 if(richiestaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6276.                     return true;
  6277.             }
  6278.             
  6279.             DumpConfigurazioneRegola richiestaUscita = configurazione.getRichiestaUscita();
  6280.             
  6281.             if(richiestaUscita != null) {
  6282.                 if(richiestaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6283.                     return true;
  6284.                 
  6285.                 if(richiestaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  6286.                     return true;
  6287.                 
  6288.                 if(richiestaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6289.                     return true;
  6290.             }
  6291.         }
  6292.         
  6293.         return abilitato;
  6294.     }
  6295.     
  6296.     
  6297.     public static final void attivazionePolicyCheckData(
  6298.             TipoOperazione tipoOperazione, 
  6299.             PortaApplicativa pa,
  6300.             AttivazionePolicy policy,
  6301.             InfoPolicy infoPolicy,  
  6302.             ErogazioniConfEnv env,
  6303.             org.openspcoop2.message.constants.ServiceBinding serviceBinding,
  6304.             String modalita) throws Exception  {

  6306.         final RuoloPolicy ruoloPorta = RuoloPolicy.APPLICATIVA;
  6307.         final String nomePorta = pa.getNome();
  6308.         // Controllo che l'azione scelta per il filtro sia supportata.
  6309.         boolean hasAzioni = pa.getAzione() != null && pa.getAzione().getAzioneDelegataList().size() > 0;
  6310.         List<String> azioniSupportate = hasAzioni 
  6311.                     ? pa.getAzione().getAzioneDelegataList()
  6312.                     : env.confCore.getAzioni(
  6313.                         env.asps,
  6314.                         env.apcCore.getAccordoServizioSintetico(env.asps.getIdAccordo()), 
  6315.                         false, 
  6316.                         true, 
  6317.                         ErogazioniApiHelper.getAzioniOccupateErogazione(env.idAsps, env.apsCore, env.paCore)
  6318.                     );
  6319.         
  6320.         if(policy.getFiltro().getAzione() != null && !policy.getFiltro().getAzione().isEmpty()) {
  6321.             String [] tmp = policy.getFiltro().getAzione().split(",");
  6322.             if(tmp!=null && tmp.length>0) {
  6323.                 for (String azCheck : tmp) {
  6324.                     if ( !azioniSupportate.contains(azCheck)) {
  6325.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'azione " + azCheck + " non è assegnabile a una policy di rate limiting per il gruppo scelto. le azioni supportare sono: " + azioniSupportate.toString());
  6326.                     }
  6327.                 }
  6328.             }
  6329.         }
  6330.         
  6331.         if(policy.getFiltro().getRuoloFruitore()!=null) {
  6332.             
  6333.             FiltroRicercaRuoli filtroRicercaRuoli = new FiltroRicercaRuoli();
  6334.             filtroRicercaRuoli.setTipologia(RuoloTipologia.INTERNO);
  6335.             List<IDRuolo> listIdRuoli = env.ruoliCore.getAllIdRuoli(filtroRicercaRuoli);
  6336.             List<String> ruoli = new ArrayList<>();
  6337.             if(listIdRuoli!=null && !listIdRuoli.isEmpty()) {
  6338.                 for (IDRuolo idRuolo : listIdRuoli) {
  6339.                     ruoli.add(idRuolo.getNome());
  6340.                 }
  6341.             }
  6342.             
  6343.             if ( !ruoli.contains(policy.getFiltro().getRuoloFruitore())) {
  6344.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo " + policy.getFiltro().getRuoloFruitore() + " non esiste.");
  6345.             }
  6346.         }
  6347.         
  6348.         // Controllo che l'applicativo fruitore scelto per il filtro sia supportato.
  6349.         if ( policy.getFiltro().getServizioApplicativoFruitore() != null &&             
  6350.                 !env.confCore.getServiziApplicativiFruitore(env.tipo_protocollo, null, env.idSoggetto.getTipo(), env.idSoggetto.getNome())
  6351.                 .stream()
  6352.                 .filter( id -> id.getNome().equals(policy.getFiltro().getServizioApplicativoFruitore()))
  6353.                 .findAny().isPresent()
  6354.         ) {
  6355.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il servizio applicativo fruitore " + policy.getFiltro().getServizioApplicativoFruitore() + " scelto non è assegnabile alla policy di rate limiting");
  6356.         }
  6357.         
  6358.         org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneControlloTraffico = env.confCore.getConfigurazioneControlloTraffico();
  6359.         if (! env.confHelper.attivazionePolicyCheckData(new StringBuilder(), tipoOperazione, configurazioneControlloTraffico, 
  6360.                 policy,infoPolicy, ruoloPorta, nomePorta, serviceBinding, modalita) ) {
  6361.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  6362.         }
  6363.         
  6364.     
  6365.         // Controllo che il soggetto fruitore scelto per il filtro sia supportato, SOLO IN EROGAZIONI
  6366.         if ( policy.getFiltro().getTipoFruitore() != null && policy.getFiltro().getNomeFruitore() != null ) {
  6367.             List<IDSoggetto> soggettiSupportati = new ArrayList<IDSoggetto>();
  6368.             
  6369.             boolean multitenant = env.confCore.getConfigurazioneGenerale().getMultitenant().getStato() == StatoFunzionalita.ABILITATO;
  6370.             PddCore pddCore = new PddCore(env.stationCore);
  6371.             List<IDSoggetto> listSoggetti = env.confCore.getSoggetti(env.tipo_protocollo, null);
  6372.     
  6373.             for (IDSoggetto idSoggetto : listSoggetti) {
  6374.                 if(!multitenant && policy.getFiltro().getRuoloPorta()!=null && 
  6375.                         (policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.APPLICATIVA) || policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.DELEGATA))) {
  6376.                     
  6377.                     Soggetto s = env.soggettiCore.getSoggettoRegistro(idSoggetto);
  6378.                     boolean isPddEsterna = pddCore.isPddEsterna(s.getPortaDominio());
  6379.                     if( policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.APPLICATIVA)) {
  6380.                         // devo prendere i soggetti esterni
  6381.                         if(isPddEsterna) {
  6382.                             soggettiSupportati.add(idSoggetto);
  6383.                         }
  6384.                     }
  6385.                     else {
  6386.                         //policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.DELEGATA);
  6387.                         // devo prendere i soggetti interni
  6388.                         if(!isPddEsterna) {
  6389.                             soggettiSupportati.add(idSoggetto);
  6390.                         }
  6391.                     }
  6392.                 }
  6393.                 else {
  6394.                     soggettiSupportati.add(idSoggetto);
  6395.                 }
  6396.             }
  6397.             
  6398.             final IDSoggetto idSoggettoScelto = new IDSoggetto(policy.getFiltro().getTipoFruitore(), policy.getFiltro().getNomeFruitore());
  6399.             if ( !soggettiSupportati.contains(idSoggettoScelto) ) {
  6400.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il soggetto fruitore " + idSoggettoScelto.toString() + " scelto non è assegnabile alla policy di rate limiting.\n I soggetti supportati sono: " + soggettiSupportati.toString() ); 
  6401.             }
  6402.         }
  6403.     
  6404.         
  6405.         
  6406.     }


  6409.     public static ApiCanale toApiCanale(ErogazioniEnv env, PortaApplicativa pa, AccordoServizioParteComuneSintetico apc, boolean throwException) throws Exception{
  6410.         return _toApiCanale(env, pa.getCanale(), apc, throwException);
  6411.     }
  6412.     public static ApiCanale toApiCanale(ErogazioniEnv env, PortaDelegata pd, AccordoServizioParteComuneSintetico apc, boolean throwException) throws Exception{
  6413.         return _toApiCanale(env, pd.getCanale(), apc, throwException);
  6414.     }
  6415.     private static ApiCanale _toApiCanale(ErogazioniEnv env, String canalePorta, AccordoServizioParteComuneSintetico apc, boolean throwException) throws Exception{
  6416.         ApiCanale canale = null;
  6417.         if(env.gestioneCanali) {
  6418.             canale = new ApiCanale();
  6419.             if(canalePorta!=null && !"".equals(canalePorta)) {
  6420.                 canale.setNome(canalePorta);
  6421.                 canale.setConfigurazione(CanaleEnum.IMPLEMENTAZIONE_API);
  6422.             }
  6423.             else if(apc.getCanale()!=null && !"".equals(apc.getCanale())) {
  6424.                 canale.setNome(apc.getCanale());
  6425.                 canale.setConfigurazione(CanaleEnum.API);
  6426.             }
  6427.             else {
  6428.                 canale.setNome(env.canaleDefault);
  6429.                 canale.setConfigurazione(CanaleEnum.DEFAULT);
  6430.             }
  6431.         }
  6432.         else {
  6433.             if(throwException) {
  6434.                 throw new Exception("Gestione dei canali non abilitata");
  6435.             }
  6436.         }
  6437.         return canale;
  6438.     }
  6439.     
  6440.     
  6441.     
  6442.     public static final void setFiltroApiImplementata(String uriApiImplementata, int idLista, ConsoleSearch ricerca, ErogazioniEnv env) throws Exception {
  6443.         //  tipoSoggettoReferente/nomeSoggettoReferente:nomeAccordo:versione
  6444.         String pattern1 = "^[a-z]{2,20}/[0-9A-Za-z]+:[_A-Za-z][\\-\\._A-Za-z0-9]*:\\d$";
  6445.         String pattern2 = "^[_A-Za-z][\\-\\._A-Za-z0-9]*:\\d$";
  6446.         try {
  6447.             IDAccordo idAccordo = null;
  6448.             IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  6449.             if(RegularExpressionEngine.isMatch(uriApiImplementata, pattern1)) {
  6450.                 idAccordo = idAccordoFactory.getIDAccordoFromUri(uriApiImplementata);
  6451.             }
  6452.             else if(RegularExpressionEngine.isMatch(uriApiImplementata, pattern2)) {
  6453.                 String uriCompleto = env.idSoggetto.getTipo()+"/"+env.idSoggetto.getNome()+":"+uriApiImplementata;
  6454.                 idAccordo = idAccordoFactory.getIDAccordoFromUri(uriCompleto);
  6455.             }
  6456.             else {
  6457.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("La uri fornita '"+uriApiImplementata+"' non rispetta il formato atteso '"+pattern1+"|"+pattern2+"'");
  6458.             }
  6459.             ricerca.addFilter(idLista, Filtri.FILTRO_API, idAccordoFactory.getUriFromIDAccordo(idAccordo));
  6460.         }catch(RegExpNotFoundException e) {
  6461.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("La uri fornita '"+uriApiImplementata+"' non rispetta il formato atteso '"+pattern1+"|"+pattern2+"': "+e.getMessage());
  6462.         }
  6463.     }
  6464.     
  6465.     public static boolean isConnettoreApplicativoServer(IdServizio idAsps, IDServizio idServizioFromAccordo, ErogazioniEnv env,
  6466.             String gruppo) throws DriverConfigurazioneNotFound, DriverConfigurazioneException, CoreException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  6467.         return isConnettoreApplicativoServer(getServizioApplicativo(idAsps, idServizioFromAccordo, env, gruppo));
  6468.     }
  6469.     
  6470.     public static boolean isConnettoreApplicativoServer(ServizioApplicativo sa) {
  6471.         return sa.getTipo() != null && sa.getTipo().equals(CostantiConfigurazione.SERVER);
  6472.     }
  6473.     
  6474.     public static void addInfoTokenPolicyForModI(Connettore regConnettore, ErogazioniEnv env, 
  6475.             boolean checkEsistenzaTokenPolicy) throws Exception {
  6476.         if(regConnettore.getPropertyList()!=null && regConnettore.getPropertyList().size()>0) {
  6477.             for (Property p : regConnettore.getPropertyList()) {
  6478.                 if(CostantiConnettori.CONNETTORE_TOKEN_POLICY.equals(p.getNome())){
  6479.                     if(p.getValore()!=null && StringUtils.isNotEmpty(p.getValore())) {
  6480.                         
  6481.                         if(checkEsistenzaTokenPolicy) {
  6482.                             try {
  6483.                                 env.configCore.getGenericProperties(p.getValore(), CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE, false);
  6484.                             }catch(DriverConfigurazioneNotFound notFound) {
  6485.                                 throw FaultCode.RICHIESTA_NON_VALIDA
  6486.                                     .toException("Token policy di negoziazione '"+p.getValore()+"' non esistente");
  6487.                             }
  6488.                             
  6489.                         }
  6490.                         
  6491.                         env.requestWrapper.overrideParameter(Costanti.CONSOLE_PARAMETRO_CONNETTORE_TOKEN_POLICY_VIA_API, p.getValore());
  6492.                     }
  6493.                 }
  6494.             }
  6495.         }
  6496.     }
  6497. }
Created with JaCoCo 0.8.8.202204050719