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;
  24. import static org.openspcoop2.utils.service.beans.utils.ProfiloUtils.toProfilo;

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

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

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


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

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

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

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

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

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


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

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

  287.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  288.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

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

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

  305.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  306.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

  313.     }

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

  318.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  319.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

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

  331.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  332.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

  339.     }


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

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

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

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

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

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

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


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

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

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


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

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


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

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

  518.         ret.setIdSoggetto(soggErogatore.getId());
  519.         ret.setTipoSoggettoErogatore(soggErogatore.getTipo());
  520.         ret.setNomeSoggettoErogatore(soggErogatore.getNome());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

  2525.         String nomePortaDefault = null;
  2526.         boolean isRidefinito = false;

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

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

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

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

  2625.         try {
  2626.             final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  2627.             final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  2628.             ProfiloEnum profilo = toProfilo(asps.getTipo());

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

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

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

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

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

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

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

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

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

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

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

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

  3783.     }

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

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



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



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



  3855.     public static final ApiImplInformazioniGeneraliView erogazioneToApiImplInformazioniGeneraliView(final ErogazioniEnv env,
  3856.             final AccordoServizioParteSpecifica asps) {
  3857.         ApiImplViewItem item = aspsToErogazioneViewItem(env, asps);

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

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


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



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

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


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



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

  4278.             ret.setMtom( Helper.statoFunzionalitaConfToBool(vx.getAcceptMtomMessage()) );
  4279.             ret.setStato( StatoFunzionalitaConWarningEnum.valueOf(vx.getStato().name()));
  4280.             ret.setTipo(  TipoValidazioneEnum.valueOf(vx.getTipo().name()) );
  4281.         }
  4282.         return ret;
  4283.     }


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

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


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



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

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



  4822.     public static final void fillPortaApplicativa(ControlloAccessiAutorizzazione body, final PortaApplicativa newPa) {
  4823.         final OneOfControlloAccessiAutorizzazioneAutorizzazione authz = body.getAutorizzazione();
  4824.         
  4825.         newPa.setXacmlPolicy(null);

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



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



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

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

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

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

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



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



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



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

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

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

  5498.         dest.setDescrizione(infoPolicy.getDescrizione());
  5499.         dest.setNome( PolicyUtilities.getNomeActivePolicy(src.getAlias(), src.getIdActivePolicy()));
  5500.                 
  5501.         dest.setRaggruppamento(
  5502.                 convert( src.getGroupBy(), new RateLimitingPolicyGroupBy() )
  5503.             );
  5504.      
  5505.         
  5506.         dest.setFiltro(
  5507.                 convert( src.getFiltro(), new RateLimitingPolicyFiltroFruizione() )
  5508.             );
  5509.         
  5510.         return dest;
  5511.     }

  5513.     
  5514.     
  5515.     public static final RateLimitingPolicyErogazioneView convert ( AttivazionePolicy src, InfoPolicy infoPolicy, RateLimitingPolicyErogazioneView dest ) {
  5516.         
  5517.         convert( src, infoPolicy, (RateLimitingPolicyBase) dest );

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

  5627.         
  5628.         
  5629.         dest.setSogliaRidefinita(src.isRidefinisci());
  5630.         
  5631.         if ( src.isRidefinisci()) {
  5632.             if(dimensioneMessaggio) {
  5633.                 dest.setSogliaDimensioneRichiesta(src.getValore2().intValue());
  5634.                 dest.setSogliaDimensioneRisposta(src.getValore().intValue());
  5635.             }
  5636.             else {
  5637.                 dest.setSogliaValore(src.getValore().intValue());
  5638.             }
  5639.         }
  5640.         else {
  5641.             if(dimensioneMessaggio) {
  5642.                 dest.setSogliaDimensioneRichiesta(infoPolicy.getValore2().intValue());
  5643.                 dest.setSogliaDimensioneRisposta(infoPolicy.getValore().intValue());
  5644.             }
  5645.             else {
  5646.                 dest.setSogliaValore(infoPolicy.getValore().intValue());
  5647.             }
  5648.         }
  5649.         
  5650.         
  5651.         return dest;
  5652.             
  5653.     }


  5656.     public static final void checkAzioniAdd( List<String> toAdd, List<String> occupate, List<String> presenti ) {
  5657.         
  5658.         for ( String azione : toAdd ) {
  5659.             
  5660.             if( occupate.contains(azione) ) {
  5661.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_GIA_PRESENTE));           
  5662.             }
  5663.             
  5664.             if( !presenti.contains(azione) ) {
  5665.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Azione " + azione + " non presente fra le azioni dell'accordo");
  5666.             }
  5667.         }
  5668.         
  5669.     }


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

  5782.         override (tipoRisorsa, (RateLimitingPolicyErogazione) body, protocollo, idPropietarioSa, wrap );
  5783.         
  5784.         wrap.overrideParameter(
  5785.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID, 
  5786.                 idPolicy    
  5787.             );      
  5788.     }
  5789.     

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

  5794.         override (tipoRisorsa, (RateLimitingPolicyFruizione) body, protocollo, idPropietarioSa, wrap );
  5795.         
  5796.         wrap.overrideParameter(
  5797.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID, 
  5798.                 idPolicy
  5799.             );
  5800.     }
  5801.     
  5802.     public static final void override( RateLimitingPolicyFiltro body, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5803.         if (body == null) return;
  5804.         
  5805.         if(body.getAzione()!=null && !body.getAzione().isEmpty()) {
  5806.         
  5807.             wrap.overrideParameterValues(
  5808.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE,
  5809.                     body.getAzione().toArray(new String[1])
  5810.                 );
  5811.         
  5812.         }
  5813.         
  5814.         wrap.overrideParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE, body.getApplicativoFruitore());
  5815.         
  5816.         wrap.overrideParameter(
  5817.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE,
  5818.                 evalnull( () -> body.getRuoloRichiedente() )  
  5819.             );
  5820.         
  5821.         String tokenClaims = null;
  5822.         if(body.getTokenClaims()!=null && !body.getTokenClaims().isEmpty()) {
  5823.             tokenClaims = String.join("\n", body.getTokenClaims());
  5824.         }
  5825.         if(tokenClaims!=null) {
  5826.             wrap.overrideParameter(
  5827.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS,
  5828.                     tokenClaims   
  5829.                 );
  5830.         }
  5831.         
  5832.         
  5833.         wrap.overrideParameter(
  5834.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED,
  5835.                 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ì 
  5836.             );
  5837.         
  5838.         wrap.overrideParameter(
  5839.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO,
  5840.                 evalnull( () -> Enums.tipoFiltroApplicativo.get( body.getChiaveTipo() ).toString()) 
  5841.             );
  5842.         
  5843.         wrap.overrideParameter(
  5844.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_NOME,
  5845.                 evalnull( () -> body.getChiaveNome() )  
  5846.             );
  5847.         
  5848.         wrap.overrideParameter(
  5849.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE,
  5850.                 evalnull( () -> body.getFiltroChiaveValore() ) 
  5851.             );  
  5852.     }
  5853.     
  5854.     private static final void override( RateLimitingPolicyGroupBy body,  HttpRequestWrapper wrap,
  5855.             String protocollo, boolean applicativa)
  5856.     {
  5857.         if (body == null) return;

  5859.     
  5860.         wrap.overrideParameter(
  5861.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED,
  5862.                 body != null 
  5863.                     ?  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO
  5864.                     :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_DISABILITATO
  5865.             );
  5866.         
  5867.         wrap.overrideParameter(
  5868.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_AZIONE,
  5869.                 evalnull(  () -> ServletUtils.boolToCheckBoxStatus( body.isAzione() ) )
  5870.             );  
  5871.         
  5872.         wrap.overrideParameter(
  5873.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RICHIEDENTE,
  5874.                 evalnull(  () -> ServletUtils.boolToCheckBoxStatus( body.isRichiedente() ) )
  5875.             );
  5876.         
  5877.         if(body.getToken()!=null && !body.getToken().isEmpty()) {
  5878.             
  5879.             wrap.overrideParameter(
  5880.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN,
  5881.                     evalnull(  () -> ServletUtils.boolToCheckBoxStatus( true ) )
  5882.                 );
  5883.             
  5884.             boolean modiPdnd = applicativa && org.openspcoop2.protocol.engine.constants.Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo);
  5885.             
  5886.             List<String> values = new ArrayList<>();
  5887.             for (RateLimitingPolicyGroupByTokenClaimEnum tokenClaim : body.getToken()) {
  5888.                 switch (tokenClaim) {
  5889.                 case SUBJECT:
  5890.                     values.add(TipoCredenzialeMittente.TOKEN_SUBJECT.getRawValue());
  5891.                     break;
  5892.                 case ISSUER:
  5893.                     values.add(TipoCredenzialeMittente.TOKEN_ISSUER.getRawValue());
  5894.                     break;
  5895.                 case CLIENT_ID:
  5896.                     values.add(TipoCredenzialeMittente.TOKEN_CLIENT_ID.getRawValue());
  5897.                     break;
  5898.                 case USERNAME:
  5899.                     values.add(TipoCredenzialeMittente.TOKEN_USERNAME.getRawValue());
  5900.                     break;
  5901.                 case EMAIL:
  5902.                     values.add(TipoCredenzialeMittente.TOKEN_EMAIL.getRawValue());
  5903.                     break;
  5904.                     
  5905.                 case PDND_ORGANIZATION_NAME:
  5906.                     if(!modiPdnd) {
  5907.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il criterio di raggruppamento per nome organizzazione PDND è utilizzabile solamente per erogazioni con profilo di interoperabilità ModI");
  5908.                     }
  5909.                     values.add(TipoCredenzialeMittente.PDND_ORGANIZATION_NAME.getRawValue());
  5910.                     break;  
  5911.                 case PDND_EXTERNAL_ID:
  5912.                     if(!modiPdnd) {
  5913.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il criterio di raggruppamento per identificativo esterno dell'organizzazione è utilizzabile solamente per erogazioni con profilo di interoperabilità ModI");
  5914.                     }
  5915.                     values.add(TipoCredenzialeMittente.PDND_ORGANIZATION_EXTERNAL_ID.getRawValue());
  5916.                     break;  
  5917.                 case PDND_CONSUMER_ID:
  5918.                     if(!modiPdnd) {
  5919.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il criterio di raggruppamento per consumerId dell'organizzazione PDND è utilizzabile solamente per erogazioni con profilo di interoperabilità ModI");
  5920.                     }
  5921.                     values.add(TipoCredenzialeMittente.PDND_ORGANIZATION_CONSUMER_ID.getRawValue());
  5922.                     break;  
  5923.                 default:
  5924.                     break;
  5925.                 }
  5926.             }
  5927.             if(!values.isEmpty()) {
  5928.                 wrap.overrideParameterValues(
  5929.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN_CLAIMS,
  5930.                         values.toArray(new String[1])
  5931.                     );
  5932.             }
  5933.         }       
  5934.         
  5935.         wrap.overrideParameter(
  5936.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED,
  5937.                 evalnull(  () -> ServletUtils.boolToCheckBoxStatus( body.getChiaveTipo() != null ) )  
  5938.             );
  5939.         
  5940.         wrap.overrideParameter(
  5941.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO,
  5942.                 evalnull( () -> Enums.tipoFiltroApplicativo.get(body.getChiaveTipo()).toString() )
  5943.             );
  5944.         
  5945.         wrap.overrideParameter(
  5946.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_NOME,
  5947.                 evalnull( () -> body.getChiaveNome() )
  5948.             ); 
  5949.     }
  5950.     
  5951.     public static final void override(TipoRisorsa tipoRisorsa, RateLimitingPolicyErogazioneUpdate body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) {
  5952.         if (body == null) return;

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

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

  5984.         override(tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  5985.         
  5986.         wrap.overrideParameter(
  5987.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  5988.                 RuoloPolicy.APPLICATIVA.toString() 
  5989.         );
  5990.         
  5991.         // Campi in più rispetto al padre:
  5992.         RateLimitingPolicyFiltroErogazione filtro = body.getFiltro();
  5993.         override( filtro, idPropietarioSa, wrap );
  5994.         
  5995.         if(filtro!=null) {
  5996.             final String filtroFruitore = evalnull(() -> filtro.getSoggettoFruitore()) != null   
  5997.                     ? new IDSoggetto(idPropietarioSa.getTipo(), filtro.getSoggettoFruitore()).toString()
  5998.                     : null;
  5999.             
  6000.             wrap.overrideParameter(
  6001.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE,
  6002.                     filtroFruitore 
  6003.                 );
  6004.         }
  6005.         
  6006.         RateLimitingPolicyGroupBy groupCriteria = body.getRaggruppamento();
  6007.         override( groupCriteria, wrap,
  6008.                 protocollo, true );

  6010.     }
  6011.     
  6012.     
  6013.     
  6014.     public static final void override (TipoRisorsa tipoRisorsa,  RateLimitingPolicyFruizioneUpdate body,  String protocollo, IDSoggetto idPropietarioSa,  HttpRequestWrapper wrap ) {   // Questa è in comune alla update.
  6015.         if (body == null) return;

  6017.         override ( tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  6018.         override ( body.getFiltro(), idPropietarioSa, wrap );
  6019.         override ( body.getRaggruppamento() , wrap,
  6020.                 protocollo, false );
  6021.         
  6022.         wrap.overrideParameter(
  6023.             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  6024.             RuoloPolicy.DELEGATA.toString() 
  6025.         );
  6026.     }
  6027.     public static final void override (TipoRisorsa tipoRisorsa,  RateLimitingPolicyFruizione body,  String protocollo, IDSoggetto idPropietarioSa,  HttpRequestWrapper wrap ) { // Questa è in comune alla update.
  6028.         if (body == null) return;

  6030.         override ( tipoRisorsa, (RateLimitingPolicyBase) body, protocollo, idPropietarioSa, wrap );
  6031.         override ( body.getFiltro(), idPropietarioSa, wrap );
  6032.         override ( body.getRaggruppamento() , wrap,
  6033.                 protocollo, false  );
  6034.         
  6035.         wrap.overrideParameter(
  6036.             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD,
  6037.             RuoloPolicy.DELEGATA.toString() 
  6038.         );
  6039.         
  6040.     }
  6041.         
  6042.     public static final void override (TipoRisorsa tipoRisorsa, RateLimitingPolicyBase body, String protocollo, IDSoggetto idPropietarioSa, HttpRequestWrapper wrap ) { // Questa è in comune alla update.      
  6043.         if (body == null) return;

  6045.         wrap.overrideParameter(
  6046.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS,
  6047.                 body.getNome()
  6048.             );      
  6049.         
  6050.         wrap.overrideParameter(
  6051.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ENABLED,
  6052.                 body.getStato().toString()
  6053.                 );
  6054.         
  6055.         wrap.overrideParameter(
  6056.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_RIDEFINISCI,
  6057.                 ServletUtils.boolToCheckBoxStatus( body.isSogliaRidefinita() )
  6058.             );
  6059.         
  6060.         
  6061.         if(body.isSogliaRidefinita()) {
  6062.             if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  6063.                 
  6064.                 if(body.getSogliaDimensioneRichiesta()==null) {
  6065.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Soglia relativa alla dimensione della richiesta non fornita");
  6066.                 }
  6067.                 if(body.getSogliaDimensioneRisposta()==null) {
  6068.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Soglia relativa alla dimensione della risposta non fornita");
  6069.                 }
  6070.                 if(body.getSogliaValore()!=null) {
  6071.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Valore di Soglia non utilizzabile con una policy di tipo '"+RateLimitingCriteriMetricaEnum.DIMENSIONE_MASSIMA.toString()+"'");
  6072.                 }
  6073.                 
  6074.                 wrap.overrideParameter(
  6075.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE_2, 
  6076.                         evalnull( () -> body.getSogliaDimensioneRichiesta().toString() )
  6077.                     );
  6078.                 
  6079.                 wrap.overrideParameter(
  6080.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE, 
  6081.                         evalnull( () -> body.getSogliaDimensioneRisposta().toString() )
  6082.                     );
  6083.                 
  6084.             }
  6085.             else {
  6086.             
  6087.                 if(body.getSogliaDimensioneRichiesta()!=null) {
  6088.                     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()+"'");
  6089.                 }
  6090.                 if(body.getSogliaDimensioneRisposta()!=null) {
  6091.                     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()+"'");
  6092.                 }
  6093.                 if(body.getSogliaValore()==null) {
  6094.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Valore di Soglia non fornito");
  6095.                 }
  6096.                 
  6097.                 wrap.overrideParameter(
  6098.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE, 
  6099.                         evalnull( () -> body.getSogliaValore().toString() )
  6100.                     );
  6101.                 
  6102.             }
  6103.         }
  6104.         
  6105.         wrap.overrideParameter(
  6106.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED,
  6107.                 StatoFunzionalita.ABILITATO.toString() 
  6108.             );
  6109.         
  6110.         wrap.overrideParameter(
  6111.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO,
  6112.                 protocollo 
  6113.             );
  6114.     }


  6117.     public static final boolean correlazioneApplicativaRichiestaCheckData(
  6118.             TipoOperazione tipoOp,
  6119.             HttpRequestWrapper wrap,
  6120.             ConsoleHelper paHelper,
  6121.             boolean isDelegata,
  6122.             CorrelazioneApplicativaRichiesta body,
  6123.             Long idPorta,
  6124.             Long idCorrelazione,
  6125.             org.openspcoop2.message.constants.ServiceBinding serviceBinding
  6126.             
  6127.         ) throws Exception {
  6128.         
  6129.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID, idPorta.toString() );
  6130.         
  6131.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ELEMENTO_XML, body.getElemento() );        // Campo elemento oppure "Qualsiasi"
  6132.         
  6133.         wrap.overrideParameter( 
  6134.                 CostantiControlStation.PARAMETRO_MODE_CORRELAZIONE_APPLICATIVA, 
  6135.                 CorrelazioneApplicativaRichiestaIdentificazione.valueOf(body.getIdentificazioneTipo().name()).toString()
  6136.             );
  6137.         
  6138.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_PATTERN, body.getIdentificazione() );
  6139.         
  6140.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID_CORRELAZIONE, evalnull( () -> idCorrelazione.toString() ) );                    // Questo va impostato nella update.
  6141.         
  6142.         return paHelper.correlazioneApplicativaRichiestaCheckData(tipoOp,isDelegata,
  6143.                 serviceBinding);
  6144.         
  6145.     }
  6146.     
  6147.     
  6148.     public static final CorrelazioneApplicativaElemento convert(CorrelazioneApplicativaRichiesta body) {
  6149.         
  6150.         CorrelazioneApplicativaElemento cae = new CorrelazioneApplicativaElemento();
  6151.         cae.setNome(body.getElemento());
  6152.         cae.setIdentificazione(CorrelazioneApplicativaRichiestaIdentificazione.valueOf(body.getIdentificazioneTipo().name()));
  6153.         
  6154.         if ( body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.URL_BASED 
  6155.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.HEADER_BASED 
  6156.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.CONTENT_BASED
  6157.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.TEMPLATE
  6158.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.FREEMARKER_TEMPLATE
  6159.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRichiestaEnum.VELOCITY_TEMPLATE) {
  6160.             
  6161.             cae.setPattern(body.getIdentificazione());
  6162.         }
  6163.         
  6164.         if ( body.getIdentificazioneTipo() != CorrelazioneApplicativaRichiestaEnum.DISABILITATO ) {
  6165.             
  6166.             cae.setIdentificazioneFallita(body.isGenerazioneErroreIdentificazioneFallita()
  6167.                     ? CorrelazioneApplicativaGestioneIdentificazioneFallita.BLOCCA 
  6168.                     : CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6169.                 );
  6170.         }
  6171.         return cae;
  6172.     }
  6173.     
  6174.         
  6175.     public static final CorrelazioneApplicativaRispostaElemento convert(CorrelazioneApplicativaRisposta body) {

  6177.         CorrelazioneApplicativaRispostaElemento cae = new CorrelazioneApplicativaRispostaElemento();
  6178.         cae.setNome(body.getElemento());
  6179.         cae.setIdentificazione(CorrelazioneApplicativaRispostaIdentificazione.valueOf(body.getIdentificazioneTipo().name()));
  6180.         
  6181.         if (     body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.HEADER_BASED 
  6182.             ||   body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.CONTENT_BASED
  6183.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.TEMPLATE
  6184.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.FREEMARKER_TEMPLATE
  6185.             ||  body.getIdentificazioneTipo() == CorrelazioneApplicativaRispostaEnum.VELOCITY_TEMPLATE  ) {
  6186.             
  6187.             cae.setPattern(body.getIdentificazione());
  6188.         }
  6189.         
  6190.         if ( body.getIdentificazioneTipo() != CorrelazioneApplicativaRispostaEnum.DISABILITATO ) {
  6191.             
  6192.             cae.setIdentificazioneFallita(body.isGenerazioneErroreIdentificazioneFallita()
  6193.                     ? CorrelazioneApplicativaGestioneIdentificazioneFallita.BLOCCA 
  6194.                     : CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6195.                 );
  6196.         }
  6197.         return cae;
  6198.     }
  6199.     
  6200.     
  6201.     public static final boolean correlazioneApplicativaRispostaCheckData(
  6202.             TipoOperazione tipoOp,
  6203.             HttpRequestWrapper wrap,
  6204.             ConsoleHelper paHelper,
  6205.             boolean isDelegata,
  6206.             CorrelazioneApplicativaRisposta body,
  6207.             Long idPorta,
  6208.             Long idCorrelazione,
  6209.             org.openspcoop2.message.constants.ServiceBinding serviceBinding
  6210.         ) throws Exception {
  6211.         
  6212.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID, idPorta.toString() );
  6213.         
  6214.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ELEMENTO_XML, body.getElemento() );        // Campo elemento oppure "Qualsiasi"
  6215.         
  6216.         wrap.overrideParameter( 
  6217.                 CostantiControlStation.PARAMETRO_MODE_CORRELAZIONE_APPLICATIVA, 
  6218.                 CorrelazioneApplicativaRichiestaIdentificazione.valueOf(body.getIdentificazioneTipo().name()).toString()
  6219.             );
  6220.         
  6221.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_PATTERN, body.getIdentificazione() );
  6222.         
  6223.         wrap.overrideParameter( CostantiControlStation.PARAMETRO_ID_CORRELAZIONE, evalnull( () -> idCorrelazione.toString() ));
  6224.     
  6225.         
  6226.         return paHelper.correlazioneApplicativaRichiestaCheckData(TipoOperazione.ADD,isDelegata,
  6227.                 serviceBinding);
  6228.         
  6229.     }



  6233.     public static final CorrelazioneApplicativaRichiesta convert( CorrelazioneApplicativaElemento  src) {
  6234.         CorrelazioneApplicativaRichiesta ret = new CorrelazioneApplicativaRichiesta();
  6235.         
  6236.         ret.setElemento( StringUtils.isEmpty(src.getNome())
  6237.                 ? "*"
  6238.                 : src.getNome()
  6239.             );
  6240.         
  6241.         ret.setGenerazioneErroreIdentificazioneFallita(src.getIdentificazioneFallita() == CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6242.                 ? false
  6243.                 : true
  6244.             );
  6245.         
  6246.         ret.setIdentificazione(src.getPattern());
  6247.         ret.setIdentificazioneTipo(CorrelazioneApplicativaRichiestaEnum.valueOf(src.getIdentificazione().name()));
  6248.         
  6249.         return ret;
  6250.     }
  6251.     
  6252.     
  6253.     public static final CorrelazioneApplicativaRisposta convert( CorrelazioneApplicativaRispostaElemento  src) {
  6254.         CorrelazioneApplicativaRisposta ret = new CorrelazioneApplicativaRisposta();
  6255.         
  6256.         ret.setElemento( StringUtils.isEmpty(src.getNome())
  6257.                 ? "*"
  6258.                 : src.getNome()
  6259.             );
  6260.         
  6261.         ret.setGenerazioneErroreIdentificazioneFallita(src.getIdentificazioneFallita() == CorrelazioneApplicativaGestioneIdentificazioneFallita.ACCETTA
  6262.                 ? false
  6263.                 : true
  6264.             );
  6265.         
  6266.         ret.setIdentificazione(src.getPattern());
  6267.         ret.setIdentificazioneTipo(CorrelazioneApplicativaRispostaEnum.valueOf(src.getIdentificazione().name()));
  6268.         
  6269.         return ret;
  6270.     }
  6271.     
  6272.     public static final boolean isDumpConfigurazioneAbilitato(DumpConfigurazione configurazione, boolean isRisposta) {
  6273.         boolean abilitato = false;
  6274.         
  6275.         if(configurazione == null)
  6276.             return false;
  6277.         
  6278.         if(isRisposta) {
  6279.             DumpConfigurazioneRegola rispostaIngresso = configurazione.getRispostaIngresso();
  6280.             
  6281.             if(rispostaIngresso != null) {
  6282.                 if(rispostaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6283.                     return true;
  6284.                 
  6285.                 if(rispostaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  6286.                     return true;
  6287.                 
  6288.                 if(rispostaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6289.                     return true;
  6290.             }
  6291.             
  6292.             DumpConfigurazioneRegola rispostaUscita = configurazione.getRispostaUscita();
  6293.             
  6294.             if(rispostaUscita != null) {
  6295.                 if(rispostaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6296.                     return true;
  6297.                 
  6298.                 if(rispostaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  6299.                     return true;
  6300.                 
  6301.                 if(rispostaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6302.                     return true;
  6303.             }
  6304.         } else {
  6305.             DumpConfigurazioneRegola richiestaIngresso = configurazione.getRichiestaIngresso();
  6306.             
  6307.             if(richiestaIngresso != null) {
  6308.                 if(richiestaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6309.                     return true;
  6310.                 
  6311.                 if(richiestaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  6312.                     return true;
  6313.                 
  6314.                 if(richiestaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6315.                     return true;
  6316.             }
  6317.             
  6318.             DumpConfigurazioneRegola richiestaUscita = configurazione.getRichiestaUscita();
  6319.             
  6320.             if(richiestaUscita != null) {
  6321.                 if(richiestaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  6322.                     return true;
  6323.                 
  6324.                 if(richiestaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  6325.                     return true;
  6326.                 
  6327.                 if(richiestaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  6328.                     return true;
  6329.             }
  6330.         }
  6331.         
  6332.         return abilitato;
  6333.     }
  6334.     
  6335.     
  6336.     public static final void attivazionePolicyCheckData(
  6337.             TipoOperazione tipoOperazione, 
  6338.             PortaApplicativa pa,
  6339.             AttivazionePolicy policy,
  6340.             InfoPolicy infoPolicy,  
  6341.             ErogazioniConfEnv env,
  6342.             org.openspcoop2.message.constants.ServiceBinding serviceBinding,
  6343.             String modalita) throws Exception  {

  6345.         final RuoloPolicy ruoloPorta = RuoloPolicy.APPLICATIVA;
  6346.         final String nomePorta = pa.getNome();
  6347.         // Controllo che l'azione scelta per il filtro sia supportata.
  6348.         boolean hasAzioni = pa.getAzione() != null && pa.getAzione().getAzioneDelegataList().size() > 0;
  6349.         List<String> azioniSupportate = hasAzioni 
  6350.                     ? pa.getAzione().getAzioneDelegataList()
  6351.                     : env.confCore.getAzioni(
  6352.                         env.asps,
  6353.                         env.apcCore.getAccordoServizioSintetico(env.asps.getIdAccordo()), 
  6354.                         false, 
  6355.                         true, 
  6356.                         ErogazioniApiHelper.getAzioniOccupateErogazione(env.idAsps, env.apsCore, env.paCore)
  6357.                     );
  6358.         
  6359.         if(policy.getFiltro().getAzione() != null && !policy.getFiltro().getAzione().isEmpty()) {
  6360.             String [] tmp = policy.getFiltro().getAzione().split(",");
  6361.             if(tmp!=null && tmp.length>0) {
  6362.                 for (String azCheck : tmp) {
  6363.                     if ( !azioniSupportate.contains(azCheck)) {
  6364.                         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());
  6365.                     }
  6366.                 }
  6367.             }
  6368.         }
  6369.         
  6370.         if(policy.getFiltro().getRuoloFruitore()!=null) {
  6371.             
  6372.             FiltroRicercaRuoli filtroRicercaRuoli = new FiltroRicercaRuoli();
  6373.             filtroRicercaRuoli.setTipologia(RuoloTipologia.INTERNO);
  6374.             List<IDRuolo> listIdRuoli = env.ruoliCore.getAllIdRuoli(filtroRicercaRuoli);
  6375.             List<String> ruoli = new ArrayList<>();
  6376.             if(listIdRuoli!=null && !listIdRuoli.isEmpty()) {
  6377.                 for (IDRuolo idRuolo : listIdRuoli) {
  6378.                     ruoli.add(idRuolo.getNome());
  6379.                 }
  6380.             }
  6381.             
  6382.             if ( !ruoli.contains(policy.getFiltro().getRuoloFruitore())) {
  6383.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo " + policy.getFiltro().getRuoloFruitore() + " non esiste.");
  6384.             }
  6385.         }
  6386.         
  6387.         // Controllo che l'applicativo fruitore scelto per il filtro sia supportato.
  6388.         if ( policy.getFiltro().getServizioApplicativoFruitore() != null &&             
  6389.                 !env.confCore.getServiziApplicativiFruitore(env.tipo_protocollo, null, env.idSoggetto.getTipo(), env.idSoggetto.getNome())
  6390.                 .stream()
  6391.                 .filter( id -> id.getNome().equals(policy.getFiltro().getServizioApplicativoFruitore()))
  6392.                 .findAny().isPresent()
  6393.         ) {
  6394.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il servizio applicativo fruitore " + policy.getFiltro().getServizioApplicativoFruitore() + " scelto non è assegnabile alla policy di rate limiting");
  6395.         }
  6396.         
  6397.         org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneControlloTraffico = env.confCore.getConfigurazioneControlloTraffico();
  6398.         if (! env.confHelper.attivazionePolicyCheckData(new StringBuilder(), tipoOperazione, configurazioneControlloTraffico, 
  6399.                 policy,infoPolicy, ruoloPorta, nomePorta, serviceBinding, modalita) ) {
  6400.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  6401.         }
  6402.         
  6403.     
  6404.         // Controllo che il soggetto fruitore scelto per il filtro sia supportato, SOLO IN EROGAZIONI
  6405.         if ( policy.getFiltro().getTipoFruitore() != null && policy.getFiltro().getNomeFruitore() != null ) {
  6406.             List<IDSoggetto> soggettiSupportati = new ArrayList<IDSoggetto>();
  6407.             
  6408.             boolean multitenant = env.confCore.getConfigurazioneGenerale().getMultitenant().getStato() == StatoFunzionalita.ABILITATO;
  6409.             PddCore pddCore = new PddCore(env.stationCore);
  6410.             List<IDSoggetto> listSoggetti = env.confCore.getSoggetti(env.tipo_protocollo, null);
  6411.     
  6412.             for (IDSoggetto idSoggetto : listSoggetti) {
  6413.                 if(!multitenant && policy.getFiltro().getRuoloPorta()!=null && 
  6414.                         (policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.APPLICATIVA) || policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.DELEGATA))) {
  6415.                     
  6416.                     Soggetto s = env.soggettiCore.getSoggettoRegistro(idSoggetto);
  6417.                     boolean isPddEsterna = pddCore.isPddEsterna(s.getPortaDominio());
  6418.                     if( policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.APPLICATIVA)) {
  6419.                         // devo prendere i soggetti esterni
  6420.                         if(isPddEsterna) {
  6421.                             soggettiSupportati.add(idSoggetto);
  6422.                         }
  6423.                     }
  6424.                     else {
  6425.                         //policy.getFiltro().getRuoloPorta().equals(RuoloPolicy.DELEGATA);
  6426.                         // devo prendere i soggetti interni
  6427.                         if(!isPddEsterna) {
  6428.                             soggettiSupportati.add(idSoggetto);
  6429.                         }
  6430.                     }
  6431.                 }
  6432.                 else {
  6433.                     soggettiSupportati.add(idSoggetto);
  6434.                 }
  6435.             }
  6436.             
  6437.             final IDSoggetto idSoggettoScelto = new IDSoggetto(policy.getFiltro().getTipoFruitore(), policy.getFiltro().getNomeFruitore());
  6438.             if ( !soggettiSupportati.contains(idSoggettoScelto) ) {
  6439.                 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() ); 
  6440.             }
  6441.         }
  6442.     
  6443.         
  6444.         
  6445.     }


  6448.     public static ApiCanale toApiCanale(ErogazioniEnv env, PortaApplicativa pa, AccordoServizioParteComuneSintetico apc, boolean throwException) throws Exception{
  6449.         return _toApiCanale(env, pa.getCanale(), apc, throwException);
  6450.     }
  6451.     public static ApiCanale toApiCanale(ErogazioniEnv env, PortaDelegata pd, AccordoServizioParteComuneSintetico apc, boolean throwException) throws Exception{
  6452.         return _toApiCanale(env, pd.getCanale(), apc, throwException);
  6453.     }
  6454.     private static ApiCanale _toApiCanale(ErogazioniEnv env, String canalePorta, AccordoServizioParteComuneSintetico apc, boolean throwException) throws Exception{
  6455.         ApiCanale canale = null;
  6456.         if(env.gestioneCanali) {
  6457.             canale = new ApiCanale();
  6458.             if(canalePorta!=null && !"".equals(canalePorta)) {
  6459.                 canale.setNome(canalePorta);
  6460.                 canale.setConfigurazione(CanaleEnum.IMPLEMENTAZIONE_API);
  6461.             }
  6462.             else if(apc.getCanale()!=null && !"".equals(apc.getCanale())) {
  6463.                 canale.setNome(apc.getCanale());
  6464.                 canale.setConfigurazione(CanaleEnum.API);
  6465.             }
  6466.             else {
  6467.                 canale.setNome(env.canaleDefault);
  6468.                 canale.setConfigurazione(CanaleEnum.DEFAULT);
  6469.             }
  6470.         }
  6471.         else {
  6472.             if(throwException) {
  6473.                 throw new Exception("Gestione dei canali non abilitata");
  6474.             }
  6475.         }
  6476.         return canale;
  6477.     }
  6478.     
  6479.     
  6480.     
  6481.     public static final void setFiltroApiImplementata(String uriApiImplementata, int idLista, ConsoleSearch ricerca, ErogazioniEnv env) throws Exception {
  6482.         //  tipoSoggettoReferente/nomeSoggettoReferente:nomeAccordo:versione
  6483.         String pattern1 = "^[a-z]{2,20}/[0-9A-Za-z]+:[_A-Za-z][\\-\\._A-Za-z0-9]*:\\d$";
  6484.         String pattern2 = "^[_A-Za-z][\\-\\._A-Za-z0-9]*:\\d$";
  6485.         try {
  6486.             IDAccordo idAccordo = null;
  6487.             IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  6488.             if(RegularExpressionEngine.isMatch(uriApiImplementata, pattern1)) {
  6489.                 idAccordo = idAccordoFactory.getIDAccordoFromUri(uriApiImplementata);
  6490.             }
  6491.             else if(RegularExpressionEngine.isMatch(uriApiImplementata, pattern2)) {
  6492.                 String uriCompleto = env.idSoggetto.getTipo()+"/"+env.idSoggetto.getNome()+":"+uriApiImplementata;
  6493.                 idAccordo = idAccordoFactory.getIDAccordoFromUri(uriCompleto);
  6494.             }
  6495.             else {
  6496.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("La uri fornita '"+uriApiImplementata+"' non rispetta il formato atteso '"+pattern1+"|"+pattern2+"'");
  6497.             }
  6498.             ricerca.addFilter(idLista, Filtri.FILTRO_API, idAccordoFactory.getUriFromIDAccordo(idAccordo));
  6499.         }catch(RegExpNotFoundException e) {
  6500.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("La uri fornita '"+uriApiImplementata+"' non rispetta il formato atteso '"+pattern1+"|"+pattern2+"': "+e.getMessage());
  6501.         }
  6502.     }
  6503.     
  6504.     public static boolean isConnettoreApplicativoServer(IdServizio idAsps, IDServizio idServizioFromAccordo, ErogazioniEnv env,
  6505.             String gruppo) throws DriverConfigurazioneNotFound, DriverConfigurazioneException, CoreException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  6506.         return isConnettoreApplicativoServer(getServizioApplicativo(idAsps, idServizioFromAccordo, env, gruppo));
  6507.     }
  6508.     
  6509.     public static boolean isConnettoreApplicativoServer(ServizioApplicativo sa) {
  6510.         return sa.getTipo() != null && sa.getTipo().equals(CostantiConfigurazione.SERVER);
  6511.     }
  6512.     
  6513.     public static void addInfoTokenPolicyForModI(Connettore regConnettore, ErogazioniEnv env, 
  6514.             boolean checkEsistenzaTokenPolicy) throws Exception {
  6515.         if(regConnettore.getPropertyList()!=null && regConnettore.getPropertyList().size()>0) {
  6516.             for (Property p : regConnettore.getPropertyList()) {
  6517.                 if(CostantiConnettori.CONNETTORE_TOKEN_POLICY.equals(p.getNome())){
  6518.                     if(p.getValore()!=null && StringUtils.isNotEmpty(p.getValore())) {
  6519.                         
  6520.                         if(checkEsistenzaTokenPolicy) {
  6521.                             try {
  6522.                                 env.configCore.getGenericProperties(p.getValore(), CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE, false);
  6523.                             }catch(DriverConfigurazioneNotFound notFound) {
  6524.                                 throw FaultCode.RICHIESTA_NON_VALIDA
  6525.                                     .toException("Token policy di negoziazione '"+p.getValore()+"' non esistente");
  6526.                             }
  6527.                             
  6528.                         }
  6529.                         
  6530.                         env.requestWrapper.overrideParameter(Costanti.CONSOLE_PARAMETRO_CONNETTORE_TOKEN_POLICY_VIA_API, p.getValore());
  6531.                     }
  6532.                 }
  6533.             }
  6534.         }
  6535.     }
  6536. }
Created with JaCoCo 0.8.8.202204050719