ErogazioniConfigurazioneApiServiceImpl.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.configurazione;

  22. import static org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniApiHelper.convert;
  23. import static org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniApiHelper.correlazioneApplicativaRichiestaCheckData;
  24. import static org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniApiHelper.correlazioneApplicativaRispostaCheckData;

  26. import java.util.ArrayList;
  27. import java.util.Arrays;
  28. import java.util.List;
  29. import java.util.Optional;
  30. import java.util.stream.Collectors;

  32. import org.apache.commons.lang.StringEscapeUtils;
  33. import org.apache.commons.lang3.StringUtils;
  34. import org.openspcoop2.core.byok.BYOKUtilities;
  35. import org.openspcoop2.core.commons.CoreException;
  36. import org.openspcoop2.core.commons.Filtri;
  37. import org.openspcoop2.core.commons.Liste;
  38. import org.openspcoop2.core.config.AttributeAuthority;
  39. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  40. import org.openspcoop2.core.config.AutorizzazioneScope;
  41. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  42. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  43. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  44. import org.openspcoop2.core.config.CorsConfigurazione;
  45. import org.openspcoop2.core.config.GenericProperties;
  46. import org.openspcoop2.core.config.GestioneToken;
  47. import org.openspcoop2.core.config.PortaApplicativa;
  48. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServiziApplicativi;
  49. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  50. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetti;
  51. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetto;
  52. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneToken;
  53. import org.openspcoop2.core.config.Proprieta;
  54. import org.openspcoop2.core.config.ProtocolProperty;
  55. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  56. import org.openspcoop2.core.config.Ruolo;
  57. import org.openspcoop2.core.config.Scope;
  58. import org.openspcoop2.core.config.ServizioApplicativo;
  59. import org.openspcoop2.core.config.Soggetto;
  60. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  61. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  62. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  63. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  64. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  65. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  66. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  67. import org.openspcoop2.core.config.constants.ValidazioneContenutiApplicativiTipo;
  68. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  69. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  70. import org.openspcoop2.core.config.rs.server.api.ErogazioniConfigurazioneApi;
  71. import org.openspcoop2.core.config.rs.server.api.impl.Enums;
  72. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  73. import org.openspcoop2.core.config.rs.server.api.impl.IdServizio;
  74. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniApiHelper;
  75. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniEnv;
  76. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  77. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneApiKey;
  78. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneApiKeyConfig;
  79. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneApiKeyPosizione;
  80. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneBasic;
  81. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneCustom;
  82. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneHttps;
  83. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazionePrincipal;
  84. import org.openspcoop2.core.config.rs.server.model.ApiCanale;
  85. import org.openspcoop2.core.config.rs.server.model.ApiImplStato;
  86. import org.openspcoop2.core.config.rs.server.model.CachingRisposta;
  87. import org.openspcoop2.core.config.rs.server.model.ConfigurazioneApiCanale;
  88. import org.openspcoop2.core.config.rs.server.model.ConfigurazioneCanaleEnum;
  89. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAttributeAuthority;
  90. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutenticazione;
  91. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutenticazioneToken;
  92. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazione;
  93. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneRuoli;
  94. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneRuolo;
  95. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneScope;
  96. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneScopes;
  97. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneSoggetti;
  98. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneSoggetto;
  99. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneView;
  100. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiErogazioneAutorizzazioneApplicativi;
  101. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiErogazioneAutorizzazioneApplicativo;
  102. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiGestioneToken;
  103. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiIdentificazioneAttributi;
  104. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRichiesta;
  105. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRichiestaEnum;
  106. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRichiestaItem;
  107. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRisposta;
  108. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRispostaEnum;
  109. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRispostaItem;
  110. import org.openspcoop2.core.config.rs.server.model.ElencoProprieta;
  111. import org.openspcoop2.core.config.rs.server.model.GestioneCors;
  112. import org.openspcoop2.core.config.rs.server.model.ListaCorrelazioneApplicativaRichiesta;
  113. import org.openspcoop2.core.config.rs.server.model.ListaCorrelazioneApplicativaRisposta;
  114. import org.openspcoop2.core.config.rs.server.model.ListaRateLimitingPolicy;
  115. import org.openspcoop2.core.config.rs.server.model.OneOfControlloAccessiAutenticazioneAutenticazione;
  116. import org.openspcoop2.core.config.rs.server.model.RateLimitingCriteriMetricaEnum;
  117. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyErogazione;
  118. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyErogazioneUpdate;
  119. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyErogazioneView;
  120. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyItem;
  121. import org.openspcoop2.core.config.rs.server.model.RegistrazioneMessaggi;
  122. import org.openspcoop2.core.config.rs.server.model.RegistrazioneDiagnosticiConfigurazione;
  123. import org.openspcoop2.core.config.rs.server.model.RegistrazioneTransazioniConfigurazione;
  124. import org.openspcoop2.core.config.rs.server.model.StatoFunzionalitaConWarningEnum;
  125. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazioneEnum;
  126. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazionePrincipalToken;
  127. import org.openspcoop2.core.config.rs.server.model.Validazione;
  128. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  129. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  130. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyRaggruppamento;
  131. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  132. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  133. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  134. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  135. import org.openspcoop2.core.id.IDPortaApplicativa;
  136. import org.openspcoop2.core.id.IDServizioApplicativo;
  137. import org.openspcoop2.core.id.IDSoggetto;
  138. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  139. import org.openspcoop2.core.registry.IdSoggetto;
  140. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  141. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  142. import org.openspcoop2.core.registry.constants.RuoloContesto;
  143. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  144. import org.openspcoop2.core.registry.constants.ScopeContesto;
  145. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  146. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  147. import org.openspcoop2.core.registry.driver.db.IDSoggettoDB;
  148. import org.openspcoop2.message.constants.ServiceBinding;
  149. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneApiKey;
  150. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneBasic;
  151. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazionePrincipal;
  152. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  153. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  154. import org.openspcoop2.utils.service.BaseImpl;
  155. import org.openspcoop2.utils.service.authorization.AuthorizationConfig;
  156. import org.openspcoop2.utils.service.authorization.AuthorizationManager;
  157. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  158. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  159. import org.openspcoop2.utils.service.beans.utils.ListaUtils;
  160. import org.openspcoop2.utils.service.context.IContext;
  161. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  162. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  163. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  164. import org.openspcoop2.web.ctrlstat.servlet.ApiKeyState;
  165. import org.openspcoop2.web.ctrlstat.servlet.ConsoleUtilities;
  166. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneUtilities;
  167. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  168. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCore;
  169. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  170. /**
  171.  * ErogazioniConfigurazioneApiServiceImpl
  172.  * 
  173.  * @author $Author$
  174.  * @version $Rev$, $Date$
  175.  * 
  176.  */
  177. public class ErogazioniConfigurazioneApiServiceImpl extends BaseImpl implements ErogazioniConfigurazioneApi {

  179.     public ErogazioniConfigurazioneApiServiceImpl(){
  180.         super(org.slf4j.LoggerFactory.getLogger(ErogazioniConfigurazioneApiServiceImpl.class));
  181.     }

  183.     private AuthorizationConfig getAuthorizationConfig() throws Exception{
  184.         return new AuthorizationConfig(ServerProperties.getInstance().getProperties());
  185.     }

  187.     /**
  188.      * Aggiunta di applicativi all'elenco degli applicativi autorizzati
  189.      *
  190.      * Questa operazione consente di aggiungere applicativi all'elenco degli applicativi autorizzati
  191.      *
  192.      */
  193.     @Override
  194.     public void addErogazioneControlloAccessiAutorizzazioneApplicativi(ControlloAccessiErogazioneAutorizzazioneApplicativo body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  195.         IContext context = this.getContext();
  196.         try {
  197.             context.getLogger().info("Invocazione in corso ...");

  199.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  200.             context.getLogger().debug("Autorizzazione completata con successo");
  201.             
  202.             BaseHelper.throwIfNull(body);
  203.             
  204.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  205.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);

  207.             boolean isProfiloModi = env.isProfiloModi();
  208.             
  209.             boolean tokenAbilitato = pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null;
  210.             
  211.             boolean modiSicurezzaMessaggio = false;
  212.             if(isProfiloModi) {
  213.                 final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  214.                 ProtocolProperties protocolProperties = ErogazioniApiHelper.getProtocolProperties(asps, env);
  215.                 if(protocolProperties!=null && protocolProperties.sizeProperties()>0) {
  216.                     modiSicurezzaMessaggio = true;
  217.                 }
  218.             }
  219.             
  220.             if(isProfiloModi) {
  221.                 boolean enabled = pa.getServiziApplicativiAutorizzati()!=null && pa.sizeServizioApplicativoList()>0; // retrocompatibilita
  222.                 if(!enabled) {
  223.                     enabled = pa.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneApplicativi());
  224.                 }
  225.                 if(!enabled) {
  226.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione messaggio per richiedente non è abilitata");
  227.                 }
  228.             }
  229.             else {
  230.                 if ( !TipoAutorizzazione.isAuthenticationRequired(pa.getAutorizzazione()) ) {
  231.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione trasporto per richiedente non è abilitata");
  232.                 }
  233.             }
  234.             
  235.             IdSoggetto idSoggettoProprietarioSA = (IdSoggetto) env.idSoggetto.clone();
  236.             if(org.apache.commons.lang.StringUtils.isNotEmpty(body.getSoggetto())) {
  237.                 idSoggettoProprietarioSA.setNome(body.getSoggetto());
  238.                 try {
  239.                     idSoggettoProprietarioSA.setId(env.soggettiCore.getIdSoggetto(body.getSoggetto(),env.tipo_soggetto));
  240.                 } catch (Exception e) {}
  241.             }
  242.             
  243.             final IDServizioApplicativo idSA = new IDServizioApplicativo();
  244.             idSA.setIdSoggettoProprietario(idSoggettoProprietarioSA.toIDSoggetto());
  245.             idSA.setNome(body.getApplicativo());
  246.             
  247.             final ServizioApplicativo sa = BaseHelper.supplyOrNonValida( 
  248.                     () -> env.saCore.getServizioApplicativo(idSA),
  249.                     "Servizio Applicativo " + idSA.toString()
  250.                 );
  251.                     
  252.             
  253.             org.openspcoop2.core.config.constants.CredenzialeTipo tipoAutenticazione = null;
  254.             boolean check = true;
  255.             boolean bothSslAndToken = false;
  256.             if(isProfiloModi) {
  257.                 
  258.                 if(!tokenAbilitato && !modiSicurezzaMessaggio) {
  259.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è possibile registrare alcun applicativo: non è stata riscontrato alcun criterio di sicurezza (messaggio o token)");
  260.                 }
  261.                 
  262.                 bothSslAndToken = tokenAbilitato && modiSicurezzaMessaggio;
  263.                 
  264.                 boolean dominioInterno = env.isDominioInterno(idSA.getIdSoggettoProprietario());
  265.                 if(dominioInterno) {
  266.                     boolean sicurezzaMessaggio = false;
  267.                     boolean sicurezzaToken = false;
  268.                     if(sa.sizeProtocolPropertyList()>0) {
  269.                         for (ProtocolProperty pp : sa.getProtocolPropertyList()) {
  270.                             if(ModICostanti.MODIPA_SICUREZZA_MESSAGGIO.equals(pp.getName())) {
  271.                                 sicurezzaMessaggio = pp.getBooleanValue()!=null && pp.getBooleanValue();
  272.                             }
  273.                             else if(ModICostanti.MODIPA_SICUREZZA_TOKEN.equals(pp.getName())) {
  274.                                 sicurezzaToken = pp.getBooleanValue()!=null && pp.getBooleanValue();
  275.                             }
  276.                         }
  277.                     }
  278.                     check = false;
  279.                     
  280.                     if(bothSslAndToken) {
  281.                         if(!sicurezzaToken) {
  282.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza token richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  283.                         }
  284.                         if(!sicurezzaMessaggio) {
  285.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza messaggio richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  286.                         }
  287.                     }
  288.                     else if(tokenAbilitato) {
  289.                         if(!sicurezzaToken) {
  290.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza token richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  291.                         }
  292.                     }
  293.                     else { //if(modiSicurezzaMessaggio) {
  294.                         if(!sicurezzaMessaggio) {
  295.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza messaggio richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  296.                         }
  297.                     }
  298.                 }
  299.                 else {
  300.                     if(tokenAbilitato) {
  301.                         tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  302.                     }
  303.                     else {
  304.                         tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.SSL;
  305.                     }
  306.                 }
  307.             }
  308.             else {
  309.                 tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.toEnumConstant(pa.getAutenticazione());
  310.                 
  311.                 if(tipoAutenticazione==null) {
  312.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non risulta abilitato un tipo di autenticazione trasporto nell'erogazione selezionata");
  313.                 }
  314.                 
  315.             }
  316.             if(check) {
  317.                 Boolean appId = null;
  318.                 if(org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  319.                     ApiKeyState apiKeyState =  new ApiKeyState(env.paCore.getParametroAutenticazione(pa.getAutenticazione(), pa.getProprietaAutenticazioneList()));
  320.                     appId = apiKeyState.appIdSelected;
  321.                 }
  322.                 List<IDServizioApplicativoDB> saCompatibili = env.saCore.soggettiServizioApplicativoList(idSoggettoProprietarioSA.toIDSoggetto(),env.userLogin,tipoAutenticazione, appId,
  323.                         CostantiConfigurazione.CLIENT,
  324.                         bothSslAndToken, pa.getGestioneToken()!=null ? pa.getGestioneToken().getPolicy() : null);
  325.                 if(env.protocolFactory.createProtocolConfiguration().isSupportoAutenticazioneApplicativiErogazioni()) {
  326.                     if (!BaseHelper.findFirst(saCompatibili, s -> s.getId().equals(sa.getId())).isPresent()) {
  327.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il tipo di credenziali dell'Applicativo non sono compatibili con l'autenticazione impostata nell'erogazione selezionata");
  328.                     }
  329.                 }
  330.             }
  331.             
  332.             if (pa.getServiziApplicativiAutorizzati() == null)
  333.                 pa.setServiziApplicativiAutorizzati(new PortaApplicativaAutorizzazioneServiziApplicativi());
  334.             
  335.             if ( BaseHelper.findFirst(
  336.                         pa.getServiziApplicativiAutorizzati().getServizioApplicativoList(),
  337.                         s -> ( (sa.getNome().equals(s.getNome())) && (sa.getTipoSoggettoProprietario().equals(s.getTipoSoggettoProprietario())) && (sa.getNomeSoggettoProprietario().equals(s.getNomeSoggettoProprietario())) )
  338.                         ).isPresent()
  339.                 ) {
  340.                 throw FaultCode.CONFLITTO.toException("Servizio Applicativo già associato");
  341.             }
  342.             
  343.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, pa.getId().toString());
  344.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SOGGETTO, idSoggettoProprietarioSA.getId().toString());
  345.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SERVIZIO_APPLICATIVO_AUTORIZZATO, sa.getId().toString());
  346.             if (!env.paHelper.porteAppServizioApplicativoAutorizzatiCheckData(TipoOperazione.ADD)) {
  347.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  348.             }
  349.             
  350.             PortaApplicativaAutorizzazioneServizioApplicativo paSaAutorizzato = new PortaApplicativaAutorizzazioneServizioApplicativo();
  351.             paSaAutorizzato.setNome(sa.getNome());
  352.             paSaAutorizzato.setTipoSoggettoProprietario(idSoggettoProprietarioSA.getTipo());
  353.             paSaAutorizzato.setNomeSoggettoProprietario(idSoggettoProprietarioSA.getNome());

  355.             pa.getServiziApplicativiAutorizzati().addServizioApplicativo(paSaAutorizzato);          
  356.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  357.             
  358.             context.getLogger().info("Invocazione completata con successo");
  359.         
  360.             // Bug Fix: altrimenti viene generato 204
  361.             context.getServletResponse().setStatus(201);
  362.         }
  363.         catch(javax.ws.rs.WebApplicationException e) {
  364.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  365.             throw e;
  366.         }
  367.         catch(Throwable e) {
  368.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  369.             throw FaultCode.ERRORE_INTERNO.toException(e);
  370.         }
  371.     }
  372.     
  373.     /**
  374.      * Aggiunta di soggetti all'elenco dei soggetti autorizzati
  375.      *
  376.      * Questa operazione consente di aggiungere soggetti all'elenco dei soggetti autorizzati
  377.      *
  378.      */
  379.     @Override
  380.     public void addErogazioneControlloAccessiAutorizzazioneSoggetti(ControlloAccessiAutorizzazioneSoggetto body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  381.         IContext context = this.getContext();
  382.         try {
  383.             
  384.             // Continua da qui, assicurati che l'autorizzazione puntuale sia abilitata guardando al TipoAutorizzazioneEnum
  385.             context.getLogger().info("Invocazione in corso ...");     

  387.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  388.             context.getLogger().debug("Autorizzazione completata con successo");     
  389.                         
  390.             BaseHelper.throwIfNull(body);
  391.             
  392.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  393.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  394.             
  395.             boolean isProfiloModi = env.isProfiloModi();
  396.             
  397.             if ( !TipoAutorizzazione.isAuthenticationRequired(pa.getAutorizzazione())) {
  398.                 if(isProfiloModi) {
  399.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione canale per richiedente non è abilitata");
  400.                 }
  401.                 else {
  402.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione trasporto per richiedente non è abilitata");
  403.                 }
  404.             }
  405.                         
  406.             final IDSoggetto daAutenticareID = new IDSoggetto(env.tipo_soggetto, body.getSoggetto());
  407.             final Soggetto daAutenticare = BaseHelper.supplyOrNonValida( 
  408.                     () -> env.soggettiCore.getSoggetto(daAutenticareID),
  409.                     "Soggetto " + body.getSoggetto() + " da autenticare"
  410.                 );
  411.             
  412.             final CredenzialeTipo tipoAutenticazione = CredenzialeTipo.toEnumConstant(pa.getAutenticazione());  
  413.             if(tipoAutenticazione==null) {
  414.                 if(!env.protocolFactory.createProtocolConfiguration().isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazioni()) {
  415.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non risulta abilitato un tipo di autenticazione trasporto nell'erogazione selezionata");
  416.                 }
  417.             }
  418.             else {
  419.                 Boolean appId = null;
  420.                 if(CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  421.                     ApiKeyState apiKeyState =  new ApiKeyState(env.paCore.getParametroAutenticazione(pa.getAutenticazione(), pa.getProprietaAutenticazioneList()));
  422.                     appId = apiKeyState.appIdSelected;
  423.                 }
  424.                 final List<String> tipiSoggettiGestitiProtocollo = env.soggettiCore.getTipiSoggettiGestitiProtocollo(env.tipo_protocollo);
  425.                 
  426.                 // L'ultimo parametro è da configurare quando utilizzeremo il multitenant 
  427.                 final List<IDSoggettoDB> soggettiCompatibili = env.soggettiCore.getSoggettiFromTipoAutenticazione(tipiSoggettiGestitiProtocollo, null, tipoAutenticazione, appId, null);
  428.                 if(env.protocolFactory.createProtocolConfiguration().isSupportoAutenticazioneSoggetti()) {
  429.                     if (!BaseHelper.findFirst(soggettiCompatibili, s -> { 
  430.                             return (daAutenticare.getTipo().equals(s.getTipo()) && daAutenticare.getNome().equals(s.getNome()) ); 
  431.                         }).isPresent()) {
  432.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il tipo di credenziali del Soggetto non sono compatibili con l'autenticazione impostata nell'erogazione selezionata");
  433.                     }
  434.                 }
  435.             }
  436.             
  437.             if (pa.getSoggetti() == null) pa.setSoggetti(new PortaApplicativaAutorizzazioneSoggetti());
  438.             
  439.             if ( BaseHelper.findFirst(
  440.                     pa.getSoggetti().getSoggettoList(),
  441.                     sogg -> new IDSoggetto(sogg.getTipo(),sogg.getNome()).equals(daAutenticareID)
  442.                     ).isPresent()
  443.                 ) {
  444.                 throw FaultCode.CONFLITTO.toException("Soggetto da autorizzare già presente");
  445.             }
  446.             
  447.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, pa.getId().toString());
  448.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SOGGETTO, daAutenticare.getId().toString());
  449.             if (!env.paHelper.porteAppSoggettoCheckData(TipoOperazione.ADD)) {
  450.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  451.             }
  452.             
  453.         
  454.             PortaApplicativaAutorizzazioneSoggetto paSoggetto = new PortaApplicativaAutorizzazioneSoggetto();
  455.             paSoggetto.setTipo(daAutenticare.getTipo());
  456.             paSoggetto.setNome(daAutenticare.getNome());
  457.             
  458.             pa.getSoggetti().addSoggetto(paSoggetto);           
  459.         
  460.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  461.             
  462.             context.getLogger().info("Invocazione completata con successo");
  463.         
  464.             // Bug Fix: altrimenti viene generato 204
  465.             context.getServletResponse().setStatus(201);
  466.         }
  467.         catch(javax.ws.rs.WebApplicationException e) {
  468.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  469.             throw e;
  470.         }
  471.         catch(Throwable e) {
  472.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  473.             throw FaultCode.ERRORE_INTERNO.toException(e);
  474.         }
  475.     }
  476.     
  477.     /**
  478.      * Aggiunta di applicativi token all'elenco degli applicativi autorizzati
  479.      *
  480.      * Questa operazione consente di aggiungere applicativi token all'elenco degli applicativi autorizzati
  481.      *
  482.      */
  483.     @Override
  484.     public void addErogazioneControlloAccessiAutorizzazioneApplicativiToken(ControlloAccessiErogazioneAutorizzazioneApplicativo body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  485.         IContext context = this.getContext();
  486.         try {
  487.             context.getLogger().info("Invocazione in corso ...");     

  489.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  490.             context.getLogger().debug("Autorizzazione completata con successo");     
  491.                         
  492.             BaseHelper.throwIfNull(body);
  493.             
  494.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  495.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);

  497.             boolean isProfiloModi = env.isProfiloModi();
  498.             
  499.             boolean tokenAbilitato = pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null;
  500.             
  501.             boolean modiSicurezzaMessaggio = false;
  502.             if(isProfiloModi) {
  503.                 final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  504.                 ProtocolProperties protocolProperties = ErogazioniApiHelper.getProtocolProperties(asps, env);
  505.                 if(protocolProperties!=null && protocolProperties.sizeProperties()>0) {
  506.                     modiSicurezzaMessaggio = true;
  507.                 }
  508.             }
  509.             
  510.             if(isProfiloModi) {
  511.                 boolean enabled = pa.getServiziApplicativiAutorizzati()!=null && pa.sizeServizioApplicativoList()>0; // retrocompatibilita
  512.                 if(!enabled) {
  513.                     enabled = pa.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneApplicativi());
  514.                 }
  515.                 if(!enabled) {
  516.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione messaggio per richiedente non è abilitata");
  517.                 }
  518.             }
  519.             else {
  520.                 if(pa.getGestioneToken()==null || pa.getGestioneToken().getPolicy()==null) {
  521.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione token per richiedente non è utilizzabile, non risulta abilitata una token policy di validazione");
  522.                 }
  523.                 if(pa.getAutorizzazioneToken()==null || !StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneApplicativi())) {
  524.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione token per richiedente non è abilitata");
  525.                 }
  526.             }
  527.             String tokenPolicy = (pa.getGestioneToken()!=null) ? pa.getGestioneToken().getPolicy() : null;
  528.             
  529.             IdSoggetto idSoggettoProprietarioSA = (IdSoggetto) env.idSoggetto.clone();
  530.             if(org.apache.commons.lang.StringUtils.isNotEmpty(body.getSoggetto())) {
  531.                 idSoggettoProprietarioSA.setNome(body.getSoggetto());
  532.                 try {
  533.                     idSoggettoProprietarioSA.setId(env.soggettiCore.getIdSoggetto(body.getSoggetto(),env.tipo_soggetto));
  534.                 } catch (Exception e) {}
  535.             }
  536.             
  537.             final IDServizioApplicativo idSA = new IDServizioApplicativo();
  538.             idSA.setIdSoggettoProprietario(idSoggettoProprietarioSA.toIDSoggetto());
  539.             idSA.setNome(body.getApplicativo());
  540.             
  541.             final ServizioApplicativo sa = BaseHelper.supplyOrNonValida( 
  542.                     () -> env.saCore.getServizioApplicativo(idSA),
  543.                     "Servizio Applicativo " + idSA.toString()
  544.                 );
  545.                     
  546.             
  547.             org.openspcoop2.core.config.constants.CredenzialeTipo tipoAutenticazione = null;
  548.             boolean check = true;
  549.             boolean bothSslAndToken = false;
  550.             if(isProfiloModi) {
  551.                 
  552.                 if(!tokenAbilitato && !modiSicurezzaMessaggio) {
  553.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è possibile registrare alcun applicativo: non è stata riscontrato alcun criterio di sicurezza (messaggio o token)");
  554.                 }
  555.                 
  556.                 bothSslAndToken = tokenAbilitato && modiSicurezzaMessaggio;
  557.                 
  558.                 boolean dominioInterno = env.isDominioInterno(idSA.getIdSoggettoProprietario());
  559.                 if(dominioInterno) {
  560.                     boolean sicurezzaMessaggio = false;
  561.                     boolean sicurezzaToken = false;
  562.                     if(sa.sizeProtocolPropertyList()>0) {
  563.                         for (ProtocolProperty pp : sa.getProtocolPropertyList()) {
  564.                             if(ModICostanti.MODIPA_SICUREZZA_MESSAGGIO.equals(pp.getName())) {
  565.                                 sicurezzaMessaggio = pp.getBooleanValue()!=null && pp.getBooleanValue();
  566.                             }
  567.                             else if(ModICostanti.MODIPA_SICUREZZA_TOKEN.equals(pp.getName())) {
  568.                                 sicurezzaToken = pp.getBooleanValue()!=null && pp.getBooleanValue();
  569.                             }
  570.                         }
  571.                     }
  572.                     check = false;
  573.                     
  574.                     if(bothSslAndToken) {
  575.                         if(!sicurezzaToken) {
  576.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza token richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  577.                         }
  578.                         if(!sicurezzaMessaggio) {
  579.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza messaggio richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  580.                         }
  581.                     }
  582.                     else if(tokenAbilitato) {
  583.                         if(!sicurezzaToken) {
  584.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza token richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  585.                         }
  586.                     }
  587.                     else { //if(modiSicurezzaMessaggio) {
  588.                         if(!sicurezzaMessaggio) {
  589.                             throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'applicativo, di dominio interno, indicato non possiede una configurazione per la sicurezza messaggio richiesta per essere autorizzati ad invocare l'erogazione con profilo ModI indicata");
  590.                         }
  591.                     }
  592.                 }
  593.                 else {
  594.                     if(tokenAbilitato) {
  595.                         tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  596.                     }
  597.                     else {
  598.                         tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.SSL;
  599.                     }
  600.                 }
  601.             }
  602.             else {
  603.                 tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  604.             }
  605.             if(check) {
  606.                 Boolean appId = null;
  607.                 List<IDServizioApplicativoDB> saCompatibili = env.saCore.soggettiServizioApplicativoList(idSoggettoProprietarioSA.toIDSoggetto(),env.userLogin,tipoAutenticazione, appId,
  608.                         CostantiConfigurazione.CLIENT,
  609.                         bothSslAndToken, tokenPolicy);
  610.                 if(env.protocolFactory.createProtocolConfiguration().isSupportoAutenticazioneApplicativiErogazioni()) {
  611.                     if (!BaseHelper.findFirst(saCompatibili, s -> s.getId().equals(sa.getId())).isPresent()) {
  612.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il tipo di credenziali dell'Applicativo non sono compatibili con l'autenticazione impostata nell'erogazione selezionata");
  613.                     }
  614.                 }
  615.             }
  616.                 
  617.             if(isProfiloModi) {
  618.                 if (pa.getServiziApplicativiAutorizzati() == null)
  619.                     pa.setServiziApplicativiAutorizzati(new PortaApplicativaAutorizzazioneServiziApplicativi());
  620.             }
  621.             else {
  622.                 if(pa.getAutorizzazioneToken()==null) {
  623.                     pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  624.                 }
  625.                 if(pa.getAutorizzazioneToken().getServiziApplicativi()==null) {
  626.                     pa.getAutorizzazioneToken().setServiziApplicativi(new PortaApplicativaAutorizzazioneServiziApplicativi());
  627.                 }   
  628.             }
  629.             
  630.             List<PortaApplicativaAutorizzazioneServizioApplicativo> lSA = null;
  631.             if(isProfiloModi) {
  632.                 lSA = pa.getServiziApplicativiAutorizzati().getServizioApplicativoList();
  633.             }
  634.             else {
  635.                 lSA = pa.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList();
  636.             }
  637.             
  638.             if ( BaseHelper.findFirst(
  639.                     lSA,
  640.                         s -> ( (sa.getNome().equals(s.getNome())) && (sa.getTipoSoggettoProprietario().equals(s.getTipoSoggettoProprietario())) && (sa.getNomeSoggettoProprietario().equals(s.getNomeSoggettoProprietario())) )
  641.                         ).isPresent()
  642.                 ) {
  643.                 throw FaultCode.CONFLITTO.toException("Servizio Applicativo già associato");
  644.             }
  645.             
  646.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, pa.getId().toString());
  647.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SOGGETTO, idSoggettoProprietarioSA.getId().toString());
  648.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SERVIZIO_APPLICATIVO_AUTORIZZATO, sa.getId().toString());
  649.             if (!env.paHelper.porteAppServizioApplicativoAutorizzatiCheckData(TipoOperazione.ADD)) {
  650.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  651.             }
  652.             
  653.             PortaApplicativaAutorizzazioneServizioApplicativo paSaAutorizzato = new PortaApplicativaAutorizzazioneServizioApplicativo();
  654.             paSaAutorizzato.setNome(sa.getNome());
  655.             paSaAutorizzato.setTipoSoggettoProprietario(idSoggettoProprietarioSA.getTipo());
  656.             paSaAutorizzato.setNomeSoggettoProprietario(idSoggettoProprietarioSA.getNome());

  658.             if(isProfiloModi) {
  659.                 pa.getServiziApplicativiAutorizzati().addServizioApplicativo(paSaAutorizzato);      
  660.             }
  661.             else {
  662.                 pa.getAutorizzazioneToken().getServiziApplicativi().addServizioApplicativo(paSaAutorizzato);
  663.             }
  664.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  665.             
  666.             context.getLogger().info("Invocazione completata con successo");
  667.         
  668.             // Bug Fix: altrimenti viene generato 204
  669.             context.getServletResponse().setStatus(201);
  670.         }
  671.         catch(javax.ws.rs.WebApplicationException e) {
  672.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  673.             throw e;
  674.         }
  675.         catch(Throwable e) {
  676.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  677.             throw FaultCode.ERRORE_INTERNO.toException(e);
  678.         }
  679.     }
  680.     
  681.     /**
  682.      * Aggiunta di ruoli all'elenco dei ruoli autorizzati
  683.      *
  684.      * Questa operazione consente di aggiungere ruoli all'elenco dei ruoli autorizzati
  685.      *
  686.      */
  687.     @Override
  688.     public void addErogazioneControlloAccessiAutorizzazioneRuoli(ControlloAccessiAutorizzazioneRuolo body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  689.         IContext context = this.getContext();
  690.         try {
  691.             context.getLogger().info("Invocazione in corso ...");
  692.             
  693.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  694.             context.getLogger().debug("Autorizzazione completata con successo");
  695.             
  696.             BaseHelper.throwIfNull(body);
  697.             
  698.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  699.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  700.             
  701.             boolean isProfiloModi = env.isProfiloModi();
  702.             
  703.             if ( !TipoAutorizzazione.isRolesRequired(pa.getAutorizzazione()) ) {
  704.                 if(isProfiloModi) {
  705.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione canale per ruoli non è abilitata per il gruppo scelto");
  706.                 }
  707.                 else {
  708.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione trasporto per ruoli non è abilitata per il gruppo scelto");
  709.                 }
  710.             }
  711.             
  712.             final RuoliCore ruoliCore = new RuoliCore(env.stationCore);
  713.             BaseHelper.supplyOrNonValida( 
  714.                     () -> ruoliCore.getRuolo(body.getRuolo())
  715.                     , "Ruolo " + body.getRuolo()
  716.                 );
  717.             
  718.             if(pa.getRuoli()==null){
  719.                 pa.setRuoli(new AutorizzazioneRuoli());
  720.             }
  721.             
  722.             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  723.             filtroRuoli.setContesto(RuoloContesto.PORTA_APPLICATIVA);
  724.             filtroRuoli.setTipologia(RuoloTipologia.QUALSIASI);
  725.             if(TipoAutorizzazione.isInternalRolesRequired(pa.getAutorizzazione()) ){
  726.                 filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  727.             }
  728.             else if(TipoAutorizzazione.isExternalRolesRequired(pa.getAutorizzazione()) ){
  729.                 filtroRuoli.setTipologia(RuoloTipologia.ESTERNO);
  730.             }
  731.             
  732.             List<String> ruoliAmmessi = env.stationCore.getAllRuoli(filtroRuoli);
  733.             
  734.             if ( !ruoliAmmessi.contains(body.getRuolo())) {
  735.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo " + body.getRuolo() + "non è tra i ruoli ammissibili per il gruppo"); 
  736.             }
  737.             
  738.             final List<String> ruoliPresenti = pa.getRuoli().getRuoloList().stream().map( r -> r.getNome()).collect(Collectors.toList());
  739.             
  740.             if ( BaseHelper.findFirst( ruoliPresenti, r -> r.equals(body.getRuolo())).isPresent()) {
  741.                 throw FaultCode.CONFLITTO.toException("Il ruolo " + body.getRuolo() + " è già associato al gruppo scelto");
  742.             }
  743.             
  744.             if (!env.paHelper.ruoloCheckData(TipoOperazione.ADD, body.getRuolo(), ruoliPresenti)) {
  745.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  746.             }

  748.             Ruolo ruolo = new Ruolo();
  749.             ruolo.setNome(body.getRuolo());
  750.             pa.getRuoli().addRuolo(ruolo);

  752.             env.paCore.performUpdateOperation(env.userLogin, false, pa);

  754.             context.getLogger().info("Invocazione completata con successo");
  755.      
  756.             // Bug Fix: altrimenti viene generato 204
  757.             context.getServletResponse().setStatus(201);
  758.         }
  759.         catch(javax.ws.rs.WebApplicationException e) {
  760.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  761.             throw e;
  762.         }
  763.         catch(Throwable e) {
  764.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  765.             throw FaultCode.ERRORE_INTERNO.toException(e);
  766.         }
  767.     }
  768.     
  769.    /**
  770.      * Aggiunta di ruoli all'elenco dei ruoli token autorizzati
  771.      *
  772.      * Questa operazione consente di aggiungere ruoli all'elenco dei ruoli token autorizzati
  773.      *
  774.      */
  775.     @Override
  776.     public void addErogazioneControlloAccessiAutorizzazioneRuoliToken(ControlloAccessiAutorizzazioneRuolo body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  777.         IContext context = this.getContext();
  778.         try {
  779.             context.getLogger().info("Invocazione in corso ...");     

  781.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  782.             context.getLogger().debug("Autorizzazione completata con successo");     
  783.                         
  784.             BaseHelper.throwIfNull(body);
  785.             
  786.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  787.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  788.             
  789.             boolean isProfiloModi = env.isProfiloModi();
  790.             
  791.             if(pa.getAutorizzazioneToken()==null || !StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneRuoli())) {
  792.                 if(isProfiloModi) {
  793.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione messaggio per ruoli non è abilitata");
  794.                 }
  795.                 else {
  796.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione token per ruoli non è abilitata");
  797.                 }
  798.             }
  799.             
  800.             final RuoliCore ruoliCore = new RuoliCore(env.stationCore);
  801.             BaseHelper.supplyOrNonValida( 
  802.                     () -> ruoliCore.getRuolo(body.getRuolo())
  803.                     , "Ruolo " + body.getRuolo()
  804.                 );
  805.             
  806.             if(pa.getAutorizzazioneToken()==null) {
  807.                 pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  808.             }
  809.             if(pa.getAutorizzazioneToken().getRuoli()==null) {
  810.                 pa.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  811.             }
  812.             
  813.             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  814.             filtroRuoli.setContesto(RuoloContesto.PORTA_APPLICATIVA);
  815.             filtroRuoli.setTipologia(RuoloTipologia.QUALSIASI);
  816.             if(TipoAutorizzazione.isInternalRolesRequired(pa.getAutorizzazione()) ){
  817.                 filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  818.             }
  819.             else if(TipoAutorizzazione.isExternalRolesRequired(pa.getAutorizzazione()) ){
  820.                 filtroRuoli.setTipologia(RuoloTipologia.ESTERNO);
  821.             }
  822.             
  823.             List<String> ruoliAmmessi = env.stationCore.getAllRuoli(filtroRuoli);
  824.             
  825.             if ( !ruoliAmmessi.contains(body.getRuolo())) {
  826.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo " + body.getRuolo() + "non è tra i ruoli ammissibili per il gruppo"); 
  827.             }
  828.             
  829.             final List<String> ruoliPresenti = pa.getAutorizzazioneToken().getRuoli().getRuoloList().stream().map( r -> r.getNome()).collect(Collectors.toList());
  830.             
  831.             if ( BaseHelper.findFirst( ruoliPresenti, r -> r.equals(body.getRuolo())).isPresent()) {
  832.                 throw FaultCode.CONFLITTO.toException("Il ruolo " + body.getRuolo() + " è già associato al gruppo scelto");
  833.             }
  834.             
  835.             if (!env.paHelper.ruoloCheckData(TipoOperazione.ADD, body.getRuolo(), ruoliPresenti)) {
  836.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  837.             }

  839.             Ruolo ruolo = new Ruolo();
  840.             ruolo.setNome(body.getRuolo());
  841.             pa.getAutorizzazioneToken().getRuoli().addRuolo(ruolo);

  843.             env.paCore.performUpdateOperation(env.userLogin, false, pa);

  845.             context.getLogger().info("Invocazione completata con successo");
  846.      
  847.             // Bug Fix: altrimenti viene generato 204
  848.             context.getServletResponse().setStatus(201);
  849.         }
  850.         catch(javax.ws.rs.WebApplicationException e) {
  851.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  852.             throw e;
  853.         }
  854.         catch(Throwable e) {
  855.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  856.             throw FaultCode.ERRORE_INTERNO.toException(e);
  857.         }
  858.     }

  860.     /**
  861.      * Aggiunta di una proprietà di configurazione
  862.      *
  863.      * Questa operazione consente di registrare una proprietà di configurazione
  864.      *
  865.      */
  866.     @Override
  867.     public void addErogazioneProprieta(org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  868.         IContext context = this.getContext();
  869.         try {
  870.             context.getLogger().info("Invocazione in corso ...");     

  872.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  873.             context.getLogger().debug("Autorizzazione completata con successo");     
  874.                         
  875.             BaseHelper.throwIfNull(body);           
  876.             
  877.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  878.             if(env.paCore==null) {
  879.                 throw new CoreException("PaCore not initialized");
  880.             }
  881.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  882.             
  883.             if ((body.getNome().indexOf(" ") != -1) || (body.getValore().indexOf(" ") != -1)) {
  884.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEI_CAMPI_DI_TESTO);
  885.             }
  886.             
  887.             if(pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  888.                 for (Proprieta p : pa.getProprietaList()) {
  889.                     if(p.getNome().equals(body.getNome())) {
  890.                         throw FaultCode.CONFLITTO.toException("Proprietà " + body.getNome() + " già assegnata alla configurazione");
  891.                     }
  892.                 }
  893.             }
  894.             
  895.             Proprieta p = new Proprieta();
  896.             p.setNome(body.getNome());
  897.             if(env.paCore!=null && env.paCore.getDriverBYOKUtilities()!=null && 
  898.                     body.isEncrypted()!=null && body.isEncrypted().booleanValue()) {
  899.                 p.setValore(env.paCore.getDriverBYOKUtilities().wrap(body.getValore()));
  900.             }
  901.             else {
  902.                 if(body.getValore().length()>255) {
  903.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_VALORE_PROPRIETA_255);
  904.                 }
  905.                 p.setValore(body.getValore());
  906.             }
  907.             pa.addProprieta(p);
  908.             
  909.             env.paCore.performUpdateOperation(env.userLogin, false, pa);

  911.             context.getLogger().info("Invocazione completata con successo");
  912.          
  913.             // Bug Fix: altrimenti viene generato 204
  914.             context.getServletResponse().setStatus(201);
  915.          
  916.         }
  917.         catch(javax.ws.rs.WebApplicationException e) {
  918.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  919.             throw e;
  920.         }
  921.         catch(Throwable e) {
  922.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  923.             throw FaultCode.ERRORE_INTERNO.toException(e);
  924.         }
  925.     }

  927.     /**
  928.      * Aggiunta di scope all'elenco degli scope autorizzati
  929.      *
  930.      * Questa operazione consente di aggiungere scope all'elenco degli scope autorizzati
  931.      *
  932.      */
  933.     @Override
  934.     public void addErogazioneControlloAccessiAutorizzazioneScope(ControlloAccessiAutorizzazioneScope body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  935.         IContext context = this.getContext();
  936.         try {
  937.             context.getLogger().info("Invocazione in corso ...");     

  939.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  940.             context.getLogger().debug("Autorizzazione completata con successo");
  941.             
  942.             BaseHelper.throwIfNull(body);           
  943.             
  944.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  945.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  946.             
  947.             if(pa.getScope()==null) {
  948.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione per scope non è abilitata");
  949.             }
  950.             
  951.             FiltroRicercaScope filtroScope = new FiltroRicercaScope();
  952.             filtroScope.setContesto(ScopeContesto.PORTA_APPLICATIVA);
  953.             filtroScope.setTipologia("");
  954.             
  955.             final List<String> scopeAmmessi = env.stationCore.getAllScope(filtroScope);
  956.             final List<String> scopePresenti = pa.getScope().getScopeList().stream().map(Scope::getNome).collect(Collectors.toList());
  957.             
  958.             if ( !scopeAmmessi.contains(body.getScope())) {
  959.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Scope " + body.getScope() + " non presente fra gli scope ammissibili."); 
  960.             }
  961.             
  962.             if ( scopePresenti.contains(body.getScope()) ) {
  963.                 throw FaultCode.CONFLITTO.toException("Scope " + body.getScope() + " già assegnato al gruppo");
  964.             }
  965.             
  966.             if (!env.paHelper.scopeCheckData(TipoOperazione.ADD, body.getScope(), scopePresenti )) {
  967.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  968.                 
  969.             }

  971.             // Inserisco il scope nel db
  972.             Scope scope = new Scope();
  973.             scope.setNome(body.getScope());
  974.             pa.getScope().addScope(scope);

  976.             
  977.             env.paCore.performUpdateOperation(env.userLogin, false, pa);

  979.             context.getLogger().info("Invocazione completata con successo");
  980.          
  981.             // Bug Fix: altrimenti viene generato 204
  982.             context.getServletResponse().setStatus(201);
  983.         }
  984.         catch(javax.ws.rs.WebApplicationException e) {
  985.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  986.             throw e;
  987.         }
  988.         catch(Throwable e) {
  989.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  990.             throw FaultCode.ERRORE_INTERNO.toException(e);
  991.         }
  992.     }
  993.     
  994.     /**
  995.      * Aggiunta di una policy di rate limiting
  996.      *
  997.      * Questa operazione consente di aggiungere una policy di rate limiting
  998.      *
  999.      */
  1000.     @Override
  1001.     public void addErogazioneRateLimitingPolicy(RateLimitingPolicyErogazione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1002.         IContext context = this.getContext();
  1003.         try {
  1004.             context.getLogger().info("Invocazione in corso ...");     

  1006.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1007.             context.getLogger().debug("Autorizzazione completata con successo");
  1008.             
  1009.             BaseHelper.throwIfNull(body);
  1010.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1011.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);

  1013.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1014.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  1015.                     "Accordo Servizio Parte Specifica");
  1016.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1017.             
  1018.             AttivazionePolicy policy = new AttivazionePolicy();
  1019.             policy.setFiltro(new AttivazionePolicyFiltro());
  1020.             policy.setGroupBy(new AttivazionePolicyRaggruppamento());
  1021.             
  1022.             final RuoloPolicy ruoloPorta = RuoloPolicy.APPLICATIVA;
  1023.             final String nomePorta = pa.getNome();
  1024.             
  1025.             String modalita = ErogazioniApiHelper.getDataElementModalita(body.getConfigurazione().getIdentificazione());
  1026.             
  1027.             String idPolicy = ErogazioniApiHelper.getIdPolicy(body, env.confCore, env.confHelper);
  1028.             if(idPolicy==null) {
  1029.                 switch (body.getConfigurazione().getIdentificazione()) {
  1030.                 case POLICY:
  1031.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Policy Utente non trovata");
  1032.                 case CRITERI:
  1033.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Policy Built-In non trovata che rispettano i criteri forniti");
  1034.                 }
  1035.             }
  1036.             policy.setIdPolicy(idPolicy);
  1037.             
  1038.             // Questo lo prendo paro paro dal codice della console.
  1039.             InfoPolicy infoPolicy = env.confCore.getInfoPolicy(policy.getIdPolicy());
  1040.             String serialId = env.confCore.getNextPolicyInstanceSerialId(infoPolicy.getIdPolicy());
  1041.             policy.setIdActivePolicy(ControlloTrafficoDriverUtils.buildIdActivePolicy(infoPolicy.getIdPolicy(), serialId));
  1042.             
  1043.             ErogazioniApiHelper.override(infoPolicy.getTipoRisorsa(), body, env.protocolFactory.getProtocol(), env.idSoggetto.toIDSoggetto(), env.requestWrapper);
  1044.             
  1045.             String errorAttivazione = env.confHelper.readDatiAttivazionePolicyFromHttpParameters(policy, false, TipoOperazione.ADD, infoPolicy);
  1046.             if ( !StringUtils.isEmpty(errorAttivazione) ) {
  1047.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(errorAttivazione));
  1048.             }
  1049.             
  1050.             policy.getFiltro().setEnabled(true);
  1051.             policy.getFiltro().setProtocollo(env.tipo_protocollo);
  1052.             policy.getFiltro().setRuoloPorta(ruoloPorta);
  1053.             policy.getFiltro().setNomePorta(nomePorta);
  1054.         
  1055.             StringBuilder existsMessage = new StringBuilder();
  1056.             if ( ConfigurazioneUtilities.alreadyExists(
  1057.                     TipoOperazione.ADD,
  1058.                     env.confCore,
  1059.                     env.confHelper,
  1060.                     policy, 
  1061.                     infoPolicy,
  1062.                     ruoloPorta, 
  1063.                     nomePorta, 
  1064.                     env.apcCore.toMessageServiceBinding(apc.getServiceBinding()),
  1065.                     existsMessage, 
  1066.                     org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE,
  1067.                     modalita
  1068.                 )) {
  1069.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(existsMessage.toString()));
  1070.             }
  1071.             
  1072.             ErogazioniApiHelper.attivazionePolicyCheckData(TipoOperazione.ADD, pa, policy, infoPolicy, env, env.apcCore.toMessageServiceBinding(apc.getServiceBinding()), modalita);
  1073.             
  1074.             // aggiorno prossima posizione nella policy
  1075.             ConfigurazioneUtilities.updatePosizioneAttivazionePolicy(env.confCore, infoPolicy, policy, ruoloPorta, nomePorta);
  1076.             
  1077.             env.confCore.performCreateOperation(env.userLogin, false, policy);

  1079.             context.getLogger().info("Invocazione completata con successo");
  1080.         
  1081.             // Bug Fix: altrimenti viene generato 204
  1082.             context.getServletResponse().setStatus(201);
  1083.         }
  1084.         catch(javax.ws.rs.WebApplicationException e) {
  1085.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1086.             throw e;
  1087.         }
  1088.         catch(Throwable e) {
  1089.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1090.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1091.         }
  1092.     }
  1093.     
  1094.     /**
  1095.      * Aggiunta di una regola di correlazione applicativa
  1096.      *
  1097.      * Questa operazione consente di registrare una regola di correlazione applicativa per la richiesta
  1098.      *
  1099.      */
  1100.     @Override
  1101.     public void addErogazioneTracciamentoCorrelazioneApplicativaRichiesta(CorrelazioneApplicativaRichiesta body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1102.         IContext context = this.getContext();
  1103.         try {
  1104.             context.getLogger().info("Invocazione in corso ...");     

  1106.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1107.             context.getLogger().debug("Autorizzazione completata con successo");
  1108.             
  1109.             BaseHelper.throwIfNull(body);
  1110.             
  1111.             if ( body.getElemento() == null )
  1112.                 body.setElemento("");
  1113.                         
  1114.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1115.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1116.             final Long idPorta = pa.getId();
  1117.             
  1118.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1119.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  1120.                     "Accordo Servizio Parte Specifica");
  1121.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1122.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  1123.                         
  1124.             StringBuilder existsMessage = new StringBuilder();
  1125.             if ( ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRichiesta(env.paCore, idPorta, body.getElemento(), 0, existsMessage)) {
  1126.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(existsMessage.toString()));
  1127.             }
  1128.             
  1129.             if ( !correlazioneApplicativaRichiestaCheckData(TipoOperazione.ADD, env.requestWrapper, env.paHelper, false, body, idPorta, null,
  1130.                     serviceBinding) ) {
  1131.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  1132.             }
  1133.                                     
  1134.             CorrelazioneApplicativa ca = pa.getCorrelazioneApplicativa();
  1135.             if (ca == null) {
  1136.                 ca = new CorrelazioneApplicativa();
  1137.             }
  1138.             ca.addElemento(convert(body));
  1139.             pa.setCorrelazioneApplicativa(ca);
  1140.             
  1141.             env.paCore.performUpdateOperation(env.userLogin, false, pa);

  1143.                     
  1144.             context.getLogger().info("Invocazione completata con successo");
  1145.      
  1146.             // Bug Fix: altrimenti viene generato 204
  1147.             context.getServletResponse().setStatus(201);
  1148.         }
  1149.         catch(javax.ws.rs.WebApplicationException e) {
  1150.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1151.             throw e;
  1152.         }
  1153.         catch(Throwable e) {
  1154.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1155.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1156.         }
  1157.     }

  1159.     /**
  1160.      * Aggiunta di una regola di correlazione applicativa
  1161.      *
  1162.      * Questa operazione consente di registrare una regola di correlazione applicativa per la risposta
  1163.      *
  1164.      */
  1165.     @Override
  1166.     public void addErogazioneTracciamentoCorrelazioneApplicativaRisposta(CorrelazioneApplicativaRisposta body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1167.         IContext context = this.getContext();
  1168.         try {
  1169.             context.getLogger().info("Invocazione in corso ...");     

  1171.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1172.             context.getLogger().debug("Autorizzazione completata con successo");     
  1173.             
  1174.             BaseHelper.throwIfNull(body);
  1175.             
  1176.             if ( body.getElemento() == null )
  1177.                 body.setElemento("");
  1178.                         
  1179.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1180.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1181.             final Long idPorta = pa.getId();
  1182.             
  1183.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1184.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  1185.                     "Accordo Servizio Parte Specifica");
  1186.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1187.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  1188.             
  1189.             StringBuilder existsMessage = new StringBuilder();
  1190.             if ( ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRisposta(env.paCore, idPorta, body.getElemento(), 0, existsMessage)) {
  1191.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(existsMessage.toString()));
  1192.             }
  1193.             
  1194.             if ( !correlazioneApplicativaRispostaCheckData(TipoOperazione.ADD, env.requestWrapper, env.pdHelper, false, body, idPorta, null,
  1195.                     serviceBinding)) {
  1196.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  1197.             }
  1198.                                 
  1199.             if ( pa.getCorrelazioneApplicativaRisposta() == null)
  1200.                 pa.setCorrelazioneApplicativaRisposta(new org.openspcoop2.core.config.CorrelazioneApplicativaRisposta());
  1201.             
  1202.             pa.getCorrelazioneApplicativaRisposta().addElemento(convert(body));
  1203.             
  1204.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1205.             
  1206.             context.getLogger().info("Invocazione completata con successo");       
  1207.      
  1208.             // Bug Fix: altrimenti viene generato 204
  1209.             context.getServletResponse().setStatus(201);
  1210.         }
  1211.         catch(javax.ws.rs.WebApplicationException e) {
  1212.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1213.             throw e;
  1214.         }
  1215.         catch(Throwable e) {
  1216.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1217.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1218.         }
  1219.     }
  1220.     
  1221.     /**
  1222.      * Elimina applicativi dall'elenco degli applicativi autorizzati
  1223.      *
  1224.      * Questa operazione consente di eliminare applicativi dall'elenco degli applicativi autorizzati
  1225.      *
  1226.      */
  1227.     @Override
  1228.     public void deleteErogazioneControlloAccessiAutorizzazioneApplicativi(String nome, Integer versione, String applicativoAutorizzato, ProfiloEnum profilo, String soggetto, String soggettoApplicativo, String gruppo, String tipoServizio) {
  1229.         IContext context = this.getContext();
  1230.         try {
  1231.             context.getLogger().info("Invocazione in corso ...");     

  1233.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1234.             context.getLogger().debug("Autorizzazione completata con successo");     
  1235.             
  1236.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1237.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1238.             
  1239.             if (pa.getServiziApplicativiAutorizzati() == null)  
  1240.                 pa.setServiziApplicativiAutorizzati(new PortaApplicativaAutorizzazioneServiziApplicativi());
  1241.             
  1242.             IdSoggetto idSoggettoProprietarioSA = (IdSoggetto) env.idSoggetto.clone();
  1243.             if(org.apache.commons.lang.StringUtils.isNotEmpty(soggettoApplicativo)) {
  1244.                 idSoggettoProprietarioSA.setNome(soggettoApplicativo);
  1245.             }
  1246.             
  1247.             PortaApplicativaAutorizzazioneServizioApplicativo to_remove = BaseHelper.findAndRemoveFirst(pa.getServiziApplicativiAutorizzati().getServizioApplicativoList(), sa -> 
  1248.                 (sa.getNome().equals(applicativoAutorizzato) && 
  1249.                 idSoggettoProprietarioSA.getNome().equals(sa.getNomeSoggettoProprietario()) && 
  1250.                 idSoggettoProprietarioSA.getTipo().equals(sa.getTipoSoggettoProprietario())));
  1251.             
  1252.             if (env.delete_404 && to_remove == null) {
  1253.                 throw FaultCode.NOT_FOUND.toException("Nessun Applicativo " + applicativoAutorizzato + " (soggetto: "+idSoggettoProprietarioSA.getNome()+") è associato al gruppo scelto");
  1254.             } else if (to_remove != null) {
  1255.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1256.             }

  1258.         
  1259.             context.getLogger().info("Invocazione completata con successo");     
  1260.         }
  1261.         catch(javax.ws.rs.WebApplicationException e) {
  1262.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1263.             throw e;
  1264.         }
  1265.         catch(Throwable e) {
  1266.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1267.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1268.         }
  1269.     }
  1270.     
  1271.     /**
  1272.      * Elimina soggetti all'elenco dei soggetti autorizzati
  1273.      *
  1274.      * Questa operazione consente di eliminare soggetti all'elenco dei soggetti autorizzati
  1275.      *
  1276.      */
  1277.     @Override
  1278.     public void deleteErogazioneControlloAccessiAutorizzazioneSoggetti(String nome, Integer versione, String soggettoAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1279.         IContext context = this.getContext();
  1280.         try {
  1281.             context.getLogger().info("Invocazione in corso ...");     

  1283.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1284.             context.getLogger().debug("Autorizzazione completata con successo");     
  1285.                         

  1287.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1288.             PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1289.             
  1290.             if (pa.getSoggetti() == null)   pa.setSoggetti(new PortaApplicativaAutorizzazioneSoggetti());
  1291.             
  1292.             PortaApplicativaAutorizzazioneSoggetto to_remove = BaseHelper.findAndRemoveFirst(pa.getSoggetti().getSoggettoList(), sogg -> sogg.getNome().equals(soggettoAutorizzato));
  1293.             
  1294.             if (env.delete_404 && to_remove == null) {
  1295.                 throw FaultCode.NOT_FOUND.toException("Nessun Soggetto " + soggettoAutorizzato + " è associato al gruppo scelto"); 
  1296.             } else if ( to_remove != null ) {
  1297.             
  1298.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1299.             }
  1300.         
  1301.             context.getLogger().info("Invocazione completata con successo");
  1302.         
  1303.      
  1304.         }
  1305.         catch(javax.ws.rs.WebApplicationException e) {
  1306.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1307.             throw e;
  1308.         }
  1309.         catch(Throwable e) {
  1310.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1311.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1312.         }
  1313.     }
  1314.     
  1315.    /**
  1316.      * Elimina applicativi dall'elenco degli applicativi token autorizzati
  1317.      *
  1318.      * Questa operazione consente di eliminare applicativi token dall'elenco degli applicativi autorizzati
  1319.      *
  1320.      */
  1321.     @Override
  1322.     public void deleteErogazioneControlloAccessiAutorizzazioneApplicativiToken(String nome, Integer versione, String applicativoAutorizzato, ProfiloEnum profilo, String soggetto, String soggettoApplicativo, String gruppo, String tipoServizio) {
  1323.         IContext context = this.getContext();
  1324.         try {
  1325.             context.getLogger().info("Invocazione in corso ...");     

  1327.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1328.             context.getLogger().debug("Autorizzazione completata con successo");     
  1329.                         
  1330.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1331.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1332.             
  1333.             boolean isProfiloModi = env.isProfiloModi();
  1334.             
  1335.             if(isProfiloModi) {
  1336.                 if (pa.getServiziApplicativiAutorizzati() == null)  
  1337.                     pa.setServiziApplicativiAutorizzati(new PortaApplicativaAutorizzazioneServiziApplicativi());
  1338.             }
  1339.             else {
  1340.                 if(pa.getAutorizzazioneToken()==null) {
  1341.                     pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  1342.                 }
  1343.                 if(pa.getAutorizzazioneToken().getServiziApplicativi()==null) {
  1344.                     pa.getAutorizzazioneToken().setServiziApplicativi(new PortaApplicativaAutorizzazioneServiziApplicativi());
  1345.                 }
  1346.             }
  1347.             
  1348.             IdSoggetto idSoggettoProprietarioSA = (IdSoggetto) env.idSoggetto.clone();
  1349.             if(org.apache.commons.lang.StringUtils.isNotEmpty(soggettoApplicativo)) {
  1350.                 idSoggettoProprietarioSA.setNome(soggettoApplicativo);
  1351.             }
  1352.             
  1353.             List<PortaApplicativaAutorizzazioneServizioApplicativo> lSA = null;
  1354.             if(isProfiloModi) {
  1355.                 lSA = pa.getServiziApplicativiAutorizzati().getServizioApplicativoList();
  1356.             }
  1357.             else {
  1358.                 lSA = pa.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList(); 
  1359.             }
  1360.             
  1361.             PortaApplicativaAutorizzazioneServizioApplicativo to_remove = BaseHelper.findAndRemoveFirst(lSA, sa -> 
  1362.                 (sa.getNome().equals(applicativoAutorizzato) && 
  1363.                 idSoggettoProprietarioSA.getNome().equals(sa.getNomeSoggettoProprietario()) && 
  1364.                 idSoggettoProprietarioSA.getTipo().equals(sa.getTipoSoggettoProprietario())));
  1365.             
  1366.             if (env.delete_404 && to_remove == null) {
  1367.                 throw FaultCode.NOT_FOUND.toException("Nessun Applicativo " + applicativoAutorizzato + " (soggetto: "+idSoggettoProprietarioSA.getNome()+") è associato al gruppo scelto");
  1368.             } else if (to_remove != null) {
  1369.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1370.             }

  1372.         
  1373.             context.getLogger().info("Invocazione completata con successo");     
  1374.         }
  1375.         catch(javax.ws.rs.WebApplicationException e) {
  1376.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1377.             throw e;
  1378.         }
  1379.         catch(Throwable e) {
  1380.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1381.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1382.         }
  1383.     }

  1385.     /**
  1386.      * Elimina ruoli dall'elenco dei ruoli autorizzati
  1387.      *
  1388.      * Questa operazione consente di eliminare ruoli dall'elenco dei ruoli autorizzati
  1389.      *
  1390.      */
  1391.     @Override
  1392.     public void deleteErogazioneControlloAccessiAutorizzazioneRuoli(String nome, Integer versione, String ruoloAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1393.         IContext context = this.getContext();
  1394.         try {
  1395.             context.getLogger().info("Invocazione in corso ...");     

  1397.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1398.             context.getLogger().debug("Autorizzazione completata con successo");     
  1399.                         
  1400.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1401.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1402.             
  1403.             if (pa.getRuoli() == null)  pa.setRuoli(new AutorizzazioneRuoli());
  1404.             
  1405.             Ruolo to_remove = BaseHelper.findAndRemoveFirst(pa.getRuoli().getRuoloList(), r -> r.getNome().equals(ruoloAutorizzato));
  1406.             
  1407.             if (env.delete_404 && to_remove == null) {
  1408.                 throw FaultCode.NOT_FOUND.toException("Nessun Ruolo " + ruoloAutorizzato + " è associato al gruppo scelto"); 
  1409.             } else if ( to_remove != null ) {
  1410.             
  1411.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1412.             }
  1413.             context.getLogger().info("Invocazione completata con successo");
  1414.         
  1415.      
  1416.         }
  1417.         catch(javax.ws.rs.WebApplicationException e) {
  1418.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1419.             throw e;
  1420.         }
  1421.         catch(Throwable e) {
  1422.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1423.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1424.         }
  1425.     }
  1426.     
  1427.    /**
  1428.      * Elimina ruoli dall'elenco dei ruoli token autorizzati
  1429.      *
  1430.      * Questa operazione consente di eliminare ruoli dall'elenco dei ruoli token autorizzati
  1431.      *
  1432.      */
  1433.     @Override
  1434.     public void deleteErogazioneControlloAccessiAutorizzazioneRuoliToken(String nome, Integer versione, String ruoloAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1435.         IContext context = this.getContext();
  1436.         try {
  1437.             context.getLogger().info("Invocazione in corso ...");     

  1439.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1440.             context.getLogger().debug("Autorizzazione completata con successo");     
  1441.                         
  1442.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1443.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1444.             
  1445.             if(pa.getAutorizzazioneToken()==null) {
  1446.                 pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  1447.             }
  1448.             if(pa.getAutorizzazioneToken().getRuoli()==null) {
  1449.                 pa.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  1450.             }
  1451.             
  1452.             Ruolo to_remove = BaseHelper.findAndRemoveFirst(pa.getAutorizzazioneToken().getRuoli().getRuoloList(), r -> r.getNome().equals(ruoloAutorizzato));
  1453.             
  1454.             if (env.delete_404 && to_remove == null) {
  1455.                 throw FaultCode.NOT_FOUND.toException("Nessun Ruolo " + ruoloAutorizzato + " è associato al gruppo scelto"); 
  1456.             } else if ( to_remove != null ) {
  1457.             
  1458.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1459.             }
  1460.             context.getLogger().info("Invocazione completata con successo");
  1461.      
  1462.         }
  1463.         catch(javax.ws.rs.WebApplicationException e) {
  1464.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1465.             throw e;
  1466.         }
  1467.         catch(Throwable e) {
  1468.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1469.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1470.         }
  1471.     }

  1473.     /**
  1474.      * Elimina la proprietà di configurazione dall&#x27;elenco di quelle attivate
  1475.      *
  1476.      * Questa operazione consente di eliminare la proprietà di configurazione dall&#x27;elenco di quelle attivate
  1477.      *
  1478.      */
  1479.     @Override
  1480.     public void deleteErogazioneProprietaConfigurazione(String nome, Integer versione, String proprieta, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1481.         IContext context = this.getContext();
  1482.         try {
  1483.             context.getLogger().info("Invocazione in corso ...");     

  1485.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1486.             context.getLogger().debug("Autorizzazione completata con successo");     
  1487.                         
  1488.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1489.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1490.             
  1491.             Proprieta to_remove = null;
  1492.             if(pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  1493.                 to_remove = BaseHelper.findAndRemoveFirst(pa.getProprietaList(), p -> p.getNome().equals(proprieta));
  1494.             }
  1495.             
  1496.             if (env.delete_404 && to_remove == null) {
  1497.                 throw FaultCode.NOT_FOUND.toException("Nessuna proprietà è presente nella configurazione con nome '"+proprieta+"'"); 
  1498.             } else if ( to_remove != null ) {
  1499.             
  1500.                 env.pdCore.performUpdateOperation(env.userLogin, false, pa);
  1501.             }
  1502.         
  1503.             context.getLogger().info("Invocazione completata con successo");
  1504.         
  1505.         }
  1506.         catch(javax.ws.rs.WebApplicationException e) {
  1507.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1508.             throw e;
  1509.         }
  1510.         catch(Throwable e) {
  1511.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1512.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1513.         }
  1514.     }

  1516.     /**
  1517.      * Elimina scope dall'elenco degli scope autorizzati
  1518.      *
  1519.      * Questa operazione consente di eliminare scope dall'elenco degli scope autorizzati
  1520.      *
  1521.      */
  1522.     @Override
  1523.     public void deleteErogazioneControlloAccessiAutorizzazioneScope(String nome, Integer versione, String scopeAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1524.         IContext context = this.getContext();
  1525.         try {
  1526.             context.getLogger().info("Invocazione in corso ...");     

  1528.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1529.             context.getLogger().debug("Autorizzazione completata con successo");     
  1530.             
  1531.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1532.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1533.             
  1534.             if (pa.getScope() == null)  pa.setScope(new AutorizzazioneScope());
  1535.             
  1536.             Scope to_remove = BaseHelper.findAndRemoveFirst(pa.getScope().getScopeList(), s -> s.getNome().equals(scopeAutorizzato));
  1537.             
  1538.             if (env.delete_404 && to_remove == null) {
  1539.                 throw FaultCode.NOT_FOUND.toException("Nessuno Scope " + scopeAutorizzato + " è associato al gruppo scelto"); 
  1540.             } else if ( to_remove != null ) {
  1541.             
  1542.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1543.             }
  1544.         
  1545.             context.getLogger().info("Invocazione completata con successo");
  1546.         
  1547.      
  1548.         }
  1549.         catch(javax.ws.rs.WebApplicationException e) {
  1550.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1551.             throw e;
  1552.         }
  1553.         catch(Throwable e) {
  1554.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1555.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1556.         }
  1557.     }
  1558.     
  1559.     /**
  1560.      * Elimina la policy dall'elenco delle policies attive
  1561.      *
  1562.      * Questa operazione consente di eliminare la policy dall'elenco delle policies attive
  1563.      *
  1564.      */
  1565.     @Override
  1566.     public void deleteErogazioneRateLimitingPolicy(String nome, Integer versione, String idPolicy, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1567.         IContext context = this.getContext();
  1568.         try {
  1569.             context.getLogger().info("Invocazione in corso ...");     

  1571.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1572.             context.getLogger().debug("Autorizzazione completata con successo");     
  1573.                         
  1574.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1575.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1576.             
  1577.             List<AttivazionePolicy> policies = env.confCore.attivazionePolicyList(null, RuoloPolicy.APPLICATIVA, pa.getNome());
  1578.             AttivazionePolicy policy = BaseHelper.findFirst( policies, p -> (PolicyUtilities.getNomeActivePolicy(p.getAlias(),p.getIdActivePolicy())).equals(idPolicy) ).orElse(null);
  1579.             
  1580.             if ( policy != null ) {
  1581.                 StringBuilder inUsoMessage = new StringBuilder();
  1582.                 List<AttivazionePolicy> policyRimosse = new ArrayList<AttivazionePolicy>();
  1583.                 
  1584.                 ConfigurazioneUtilities.deleteAttivazionePolicy(
  1585.                         new ArrayList<AttivazionePolicy>(Arrays.asList( policy )), 
  1586.                         env.confHelper, 
  1587.                         env.confCore, 
  1588.                         env.userLogin, 
  1589.                         inUsoMessage, 
  1590.                         org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE, policyRimosse
  1591.                     );
  1592.                 
  1593.                 if ( inUsoMessage.length() > 0 ) {
  1594.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(inUsoMessage.toString()));
  1595.                 }
  1596.                 
  1597.             }
  1598.             else if ( env.delete_404 ) {
  1599.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting con id " + idPolicy );
  1600.             }
  1601.        
  1602.             context.getLogger().info("Invocazione completata con successo");
  1603.      
  1604.         }
  1605.         catch(javax.ws.rs.WebApplicationException e) {
  1606.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1607.             throw e;
  1608.         }
  1609.         catch(Throwable e) {
  1610.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1611.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1612.         }
  1613.     }
  1614.     
  1615.     /**
  1616.      * Elimina la regola di correlazione applicativa dall'elenco di quelle attivate per la richiesta
  1617.      *
  1618.      * Questa operazione consente di eliminare la regola di correlazione applicativa dall'elenco di quelle attivate per la richiesta
  1619.      *
  1620.      */
  1621.     @Override
  1622.     public void deleteErogazioneTracciamentoCorrelazioneApplicativaRichiesta(String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1623.         IContext context = this.getContext();
  1624.         try {
  1625.             context.getLogger().info("Invocazione in corso ...");     

  1627.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1628.             context.getLogger().debug("Autorizzazione completata con successo");     
  1629.                         
  1630.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1631.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1632.             
  1633.             final CorrelazioneApplicativa correlazioneApplicativa = pa.getCorrelazioneApplicativa();
  1634.             
  1635.             final String searchElemento = elemento.equals("*")
  1636.                     ? ""
  1637.                     : elemento; 
  1638.                                     
  1639.             CorrelazioneApplicativaElemento to_del = BaseHelper.evalnull( () -> BaseHelper.findAndRemoveFirst( 
  1640.                     correlazioneApplicativa.getElementoList(), 
  1641.                     e -> (e.getNome()==null ? "" : e.getNome()).equals(searchElemento)
  1642.                 ));
  1643.             
  1644.             if ( to_del != null ) {
  1645.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1646.             }
  1647.             
  1648.             else if (env.delete_404) {
  1649.                 throw FaultCode.NOT_FOUND.toException("Correlazione applicativa per l'elemento " + elemento + " non trovata");
  1650.             }
  1651.                 
  1652.             
  1653.             context.getLogger().info("Invocazione completata con successo");     
  1654.         }
  1655.         catch(javax.ws.rs.WebApplicationException e) {
  1656.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1657.             throw e;
  1658.         }
  1659.         catch(Throwable e) {
  1660.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1661.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1662.         }
  1663.     }
  1664.     
  1665.     /**
  1666.      * Elimina la regola di correlazione applicativa dall'elenco di quelle attivate per la risposta
  1667.      *
  1668.      * Questa operazione consente di eliminare la regola di correlazione applicativa dall'elenco di quelle attivate per la risposta
  1669.      *
  1670.      */
  1671.     @Override
  1672.     public void deleteErogazioneTracciamentoCorrelazioneApplicativaRisposta(String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1673.         IContext context = this.getContext();
  1674.         try {
  1675.             context.getLogger().info("Invocazione in corso ...");     

  1677.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1678.             context.getLogger().debug("Autorizzazione completata con successo");     
  1679.                         
  1680.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1681.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1682.             
  1683.             org.openspcoop2.core.config.CorrelazioneApplicativaRisposta correlazioneApplicativa = pa.getCorrelazioneApplicativaRisposta();
  1684.             
  1685.             final String searchElemento = elemento.equals("*")
  1686.                     ? ""
  1687.                     : elemento; 
  1688.                                     
  1689.             CorrelazioneApplicativaRispostaElemento to_del = BaseHelper.evalnull( () -> BaseHelper.findAndRemoveFirst( 
  1690.                     correlazioneApplicativa.getElementoList(), 
  1691.                     e -> (e.getNome()==null ? "" : e.getNome()).equals(searchElemento)
  1692.                 ));
  1693.             
  1694.             if ( to_del != null ) {
  1695.                 env.paCore.performUpdateOperation(env.userLogin, false, pa);
  1696.             }
  1697.             
  1698.             else if (env.delete_404) {
  1699.                 throw FaultCode.NOT_FOUND.toException("Correlazione applicativa per l'elemento " + elemento + " non trovata");
  1700.             }        
  1701.             context.getLogger().info("Invocazione completata con successo");
  1702.         
  1703.      
  1704.         }
  1705.         catch(javax.ws.rs.WebApplicationException e) {
  1706.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1707.             throw e;
  1708.         }
  1709.         catch(Throwable e) {
  1710.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1711.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1712.         }
  1713.     }
  1714.     
  1715.     /**
  1716.      * Restituisce la policy XACML associata all'autorizzazione
  1717.      *
  1718.      * Questa operazione consente di ottenere la policy XACML associata all'autorizzazione
  1719.      *
  1720.      */
  1721.     @Override
  1722.     public byte[] downloadErogazioneControlloAccessiAutorizzazioneXacmlPolicy(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1723.         IContext context = this.getContext();
  1724.         try {
  1725.             context.getLogger().info("Invocazione in corso ...");     

  1727.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1728.             context.getLogger().debug("Autorizzazione completata con successo");     
  1729.             
  1730.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1731.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1732.             
  1733.             if (pa.getXacmlPolicy() == null)
  1734.                 throw FaultCode.NOT_FOUND.toException("Xacml policy non assegnata al gruppo scelto");
  1735.             
  1736.             context.getLogger().info("Invocazione completata con successo");
  1737.             return BaseHelper.evalnull( () -> pa.getXacmlPolicy().getBytes() );

  1739.         }
  1740.         catch(javax.ws.rs.WebApplicationException e) {
  1741.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1742.             throw e;
  1743.         }
  1744.         catch(Throwable e) {
  1745.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1746.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1747.         }
  1748.     }
  1749.     
  1750.     /**
  1751.      * Restituisce l'elenco delle policy di rate limiting configurate
  1752.      *
  1753.      * Questa operazione consente di ottenere l'elenco delle policy di rate limiting configurate
  1754.      *
  1755.      */
  1756.     @Override
  1757.     public ListaRateLimitingPolicy findAllErogazioneRateLimitingPolicies(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio, String q, Integer limit, Integer offset, RateLimitingCriteriMetricaEnum metrica) {
  1758.         IContext context = this.getContext();
  1759.         try {
  1760.             context.getLogger().info("Invocazione in corso ...");     

  1762.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1763.             context.getLogger().debug("Autorizzazione completata con successo");     
  1764.             
  1765.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1766.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1767.             
  1768.             final int idLista = Liste.CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY;
  1769.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  1770.             if(metrica!=null) {
  1771.                 String risorsa = ErogazioniApiHelper.getDataElementModalitaRisorsa(metrica);
  1772.                 ricerca.addFilter(idLista, Filtri.FILTRO_TIPO_RISORSA_POLICY, risorsa);
  1773.             }
  1774.             List<AttivazionePolicy> policies = env.confCore.attivazionePolicyList(ricerca, RuoloPolicy.APPLICATIVA, pa.getNome());

  1776.             if ( env.findall_404 && policies.isEmpty() ) {
  1777.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting associata");
  1778.             }
  1779.             
  1780.             ListaRateLimitingPolicy ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1781.                     ricerca.getIndexIniziale(idLista),
  1782.                     ricerca.getPageSize(idLista), 
  1783.                     ricerca.getNumEntries(idLista), ListaRateLimitingPolicy.class);
  1784.             
  1785.             policies.forEach( p -> {
  1786.                 RateLimitingPolicyItem item = new RateLimitingPolicyItem();
  1787.                 item.setNome(PolicyUtilities.getNomeActivePolicy(p.getAlias(), p.getIdActivePolicy()));
  1788.                 ret.addItemsItem(item);
  1789.             });
  1790.                               
  1791.             context.getLogger().info("Invocazione completata con successo");
  1792.             return ret;
  1793.      
  1794.         }
  1795.         catch(javax.ws.rs.WebApplicationException e) {
  1796.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1797.             throw e;
  1798.         }
  1799.         catch(Throwable e) {
  1800.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1801.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1802.         }
  1803.     }
  1804.     
  1805.     /**
  1806.      * Restituisce l'elenco delle regole di correlazione applicativa per la richiesta
  1807.      *
  1808.      * Questa operazione consente di ottenere l'elenco delle regole di correlazione applicativa per la richiesta
  1809.      *
  1810.      */
  1811.     @Override
  1812.     public ListaCorrelazioneApplicativaRichiesta findAllErogazioneTracciamentoCorrelazioneApplicativaRichiesta(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio, String q, Integer limit, Integer offset) {
  1813.         IContext context = this.getContext();
  1814.         try {
  1815.             context.getLogger().info("Invocazione in corso ...");     

  1817.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1818.             context.getLogger().debug("Autorizzazione completata con successo");
  1819.             
  1820.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1821.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1822.             
  1823.             final int idLista = Liste.PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA;
  1824.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  1825.             
  1826.             List<CorrelazioneApplicativaElemento> lista = env.paCore.porteApplicativeCorrelazioneApplicativaList(pa.getId().intValue(), ricerca);

  1828.             if ( env.findall_404 && lista.isEmpty() ) {
  1829.                 throw FaultCode.NOT_FOUND.toException("Nessuna regola di correlazione applicativa associata");
  1830.             }
  1831.             
  1832.             ListaCorrelazioneApplicativaRichiesta ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1833.                     ricerca.getIndexIniziale(idLista),
  1834.                     ricerca.getPageSize(idLista), 
  1835.                     ricerca.getNumEntries(idLista), ListaCorrelazioneApplicativaRichiesta.class);
  1836.             
  1837.             lista.forEach( c -> {
  1838.                 CorrelazioneApplicativaRichiestaItem item = new CorrelazioneApplicativaRichiestaItem();
  1839.                 item.setElemento( StringUtils.isEmpty(c.getNome()) 
  1840.                         ? "*"
  1841.                         : c.getNome() 
  1842.                     );
  1843.                 
  1844.                 item.setIdentificazioneTipo(CorrelazioneApplicativaRichiestaEnum.valueOf(c.getIdentificazione().name()));
  1845.                 ret.addItemsItem(item);
  1846.             });

  1848.             context.getLogger().info("Invocazione completata con successo");
  1849.             return ret;
  1850.      
  1851.         }
  1852.         catch(javax.ws.rs.WebApplicationException e) {
  1853.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1854.             throw e;
  1855.         }
  1856.         catch(Throwable e) {
  1857.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1858.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1859.         }
  1860.     }
  1861.     
  1862.     /**
  1863.      * Restituisce l'elenco delle regole di correlazione applicativa per la risposta
  1864.      *
  1865.      * Questa operazione consente di ottenere l'elenco delle regole di correlazione applicativa per la risposta
  1866.      *
  1867.      */
  1868.     @Override
  1869.     public ListaCorrelazioneApplicativaRisposta findAllErogazioneTracciamentoCorrelazioneApplicativaRisposta(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio, String q, Integer limit, Integer offset) {
  1870.         IContext context = this.getContext();
  1871.         try {
  1872.             context.getLogger().info("Invocazione in corso ...");     

  1874.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1875.             context.getLogger().debug("Autorizzazione completata con successo");     
  1876.                         
  1877.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1878.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1879.             
  1880.             final int idLista = Liste.PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_RISPOSTA;
  1881.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  1882.             
  1883.             List<CorrelazioneApplicativaRispostaElemento> lista = env.paCore.porteApplicativeCorrelazioneApplicativaRispostaList(pa.getId().intValue(), ricerca);

  1885.             if ( env.findall_404 && lista.isEmpty() ) {
  1886.                 throw FaultCode.NOT_FOUND.toException("Nessuna regola di correlazione applicativa della risposta associata");
  1887.             }
  1888.             
  1889.             ListaCorrelazioneApplicativaRisposta ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1890.                     ricerca.getIndexIniziale(idLista),
  1891.                     ricerca.getPageSize(idLista), 
  1892.                     ricerca.getNumEntries(idLista), ListaCorrelazioneApplicativaRisposta.class);
  1893.             
  1894.             lista.forEach( c -> {
  1895.                 CorrelazioneApplicativaRispostaItem item = new CorrelazioneApplicativaRispostaItem();
  1896.                 item.setElemento( StringUtils.isEmpty(c.getNome()) 
  1897.                         ? "*"
  1898.                         : c.getNome() 
  1899.                     );              item.setIdentificazioneTipo(CorrelazioneApplicativaRispostaEnum.valueOf(c.getIdentificazione().name()));
  1900.                 ret.addItemsItem(item);
  1901.             });        
  1902.             
  1903.             context.getLogger().info("Invocazione completata con successo");
  1904.             return ret;
  1905.      
  1906.         }
  1907.         catch(javax.ws.rs.WebApplicationException e) {
  1908.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1909.             throw e;
  1910.         }
  1911.         catch(Throwable e) {
  1912.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1913.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1914.         }
  1915.     }
  1916.     
  1917.     /**
  1918.      * Restituisce la configurazione relativa al caching delle risposte
  1919.      *
  1920.      * Questa operazione consente di ottenere la configurazione relativa al caching delle risposte
  1921.      *
  1922.      */
  1923.     @Override
  1924.     public CachingRisposta getErogazioneCachingRisposta(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1925.         IContext context = this.getContext();
  1926.         try {
  1927.             context.getLogger().info("Invocazione in corso ...");     

  1929.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1930.             context.getLogger().debug("Autorizzazione completata con successo");
  1931.             

  1933.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  1934.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  1935.             
  1936.             CachingRisposta ret = ErogazioniApiHelper.buildCachingRisposta(pa.getResponseCaching());
  1937.                       
  1938.         
  1939.             context.getLogger().info("Invocazione completata con successo");
  1940.             return ret;
  1941.      
  1942.         }
  1943.         catch(javax.ws.rs.WebApplicationException e) {
  1944.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1945.             throw e;
  1946.         }
  1947.         catch(Throwable e) {
  1948.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1949.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1950.         }
  1951.     }
  1952.     
  1953.     /**
  1954.      * Restituisce il canale associato all'erogazione
  1955.      *
  1956.      * Questa operazione consente di ottenere il canale associato all'erogazione
  1957.      *
  1958.      */
  1959.     @Override
  1960.     public ApiCanale getErogazioneCanale(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1961.         IContext context = this.getContext();
  1962.         try {
  1963.             context.getLogger().info("Invocazione in corso ...");     

  1965.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1966.             context.getLogger().debug("Autorizzazione completata con successo");     
  1967.                         
  1968.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1969.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  1970.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  1971.             
  1972.             final IDPortaApplicativa idPa = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPADefault( idAsps, env.apsCore ),  "Gruppo default per l'erogazione scelta" );
  1973.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPa);
  1974.             
  1975.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1976.             ApiCanale canale = ErogazioniApiHelper.toApiCanale(env, pa, apc, true);
  1977.             
  1978.             context.getLogger().info("Invocazione completata con successo");
  1979.             return canale;
  1980.      
  1981.         }
  1982.         catch(javax.ws.rs.WebApplicationException e) {
  1983.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1984.             throw e;
  1985.         }
  1986.         catch(Throwable e) {
  1987.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1988.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1989.         }
  1990.     }

  1992.     /**
  1993.      * Restituisce la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  1994.      *
  1995.      * Questa operazione consente di ottenere la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  1996.      *
  1997.      */
  1998.     @Override
  1999.     public ControlloAccessiAutenticazione getErogazioneControlloAccessiAutenticazione(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2000.         IContext context = this.getContext();
  2001.         try {
  2002.             context.getLogger().info("Invocazione in corso ...");     

  2004.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2005.             context.getLogger().debug("Autorizzazione completata con successo");     
  2006.             
  2007.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2008.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2009.             
  2010.             OneOfControlloAccessiAutenticazioneAutenticazione autRet = null;
  2011.             TipoAutenticazioneEnum tipoAutenticazione = null;
  2012.             if ( TipoAutenticazione.toEnumConstant(pa.getAutenticazione()) == null ) {
  2013.                 tipoAutenticazione = TipoAutenticazioneEnum.CUSTOM;
  2014.             }
  2015.             else {      
  2016.                 tipoAutenticazione = Enums.dualizeMap(Enums.tipoAutenticazioneFromRest).get(TipoAutenticazione.toEnumConstant(pa.getAutenticazione())) ;
  2017.             }
  2018.             
  2019.             ControlloAccessiAutenticazioneToken token = BaseHelper.evalnull( () -> pa.getGestioneToken().getAutenticazione() ) != null
  2020.                     ? ErogazioniApiHelper.fromGestioneTokenAutenticazione(pa.getGestioneToken().getAutenticazione())
  2021.                     : null;         
  2022.                     
  2023.             switch(tipoAutenticazione) {
  2024.             case HTTP_BASIC: {
  2025.                 APIImplAutenticazioneBasic authnBasic = new APIImplAutenticazioneBasic();
  2026.                 authnBasic.setTipo(tipoAutenticazione);
  2027.                 authnBasic.setOpzionale(Helper.statoFunzionalitaConfToBool( pa.getAutenticazioneOpzionale() ));
  2028.                 autRet = authnBasic;
  2029.                 
  2030.                 Optional<Proprieta> prop = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazioneBasic.CLEAN_HEADER_AUTHORIZATION.equals(p.getNome())).findAny();
  2031.                 if (prop.isPresent() && prop.get().getValore().equals(ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL_TRUE))
  2032.                     authnBasic.setForward(false);
  2033.                 else
  2034.                     authnBasic.setForward(true);

  2036.                 break;
  2037.             }
  2038.             case HTTPS: {
  2039.                 APIImplAutenticazioneHttps authnHttps = new APIImplAutenticazioneHttps();
  2040.                 authnHttps.setTipo(tipoAutenticazione);
  2041.                 authnHttps.setOpzionale(Helper.statoFunzionalitaConfToBool( pa.getAutenticazioneOpzionale() ));
  2042.                 autRet = authnHttps;
  2043.                 
  2044.                 break;
  2045.             }
  2046.             case PRINCIPAL: {
  2047.                 
  2048.                 APIImplAutenticazionePrincipal authnPrincipal = new APIImplAutenticazionePrincipal();
  2049.                 authnPrincipal.setTipo(tipoAutenticazione);
  2050.                 authnPrincipal.setOpzionale(Helper.statoFunzionalitaConfToBool( pa.getAutenticazioneOpzionale() ));
  2051.                 autRet = authnPrincipal;
  2052.                 
  2053.                 TipoAutenticazionePrincipal tipoAuthnPrincipal = pa.getProprietaAutenticazioneList()
  2054.                         .stream()
  2055.                         .filter( p -> ParametriAutenticazionePrincipal.TIPO_AUTENTICAZIONE.equals(p.getNome()))
  2056.                         .map( p -> TipoAutenticazionePrincipal.toEnumConstant(p.getValore()) )
  2057.                         .findAny()
  2058.                         .orElse(TipoAutenticazionePrincipal.CONTAINER);
  2059.                 authnPrincipal.setTipoPrincipal(Enums.dualizeMap(Enums.tipoAutenticazionePrincipalFromRest).get(tipoAuthnPrincipal));
  2060.                 
  2061.                 switch (authnPrincipal.getTipoPrincipal()) {
  2062.                 case CONTAINER:
  2063.                 case IP_ADDRESS:
  2064.                 case IP_ADDRESS_FORWARDED_FOR:
  2065.                     break;
  2066.                 case HEADER_BASED: {
  2067.                     Optional<Proprieta> prop = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.NOME.equals(p.getNome())).findAny();
  2068.                     if (prop.isPresent()) authnPrincipal.setNome(prop.get().getValore());                   
  2069.                     break;
  2070.                 }
  2071.                 case FORM_BASED: {
  2072.                     Optional<Proprieta> prop = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.NOME.equals(p.getNome())).findAny();
  2073.                     if (prop.isPresent()) authnPrincipal.setNome(prop.get().getValore());                   
  2074.                     break;
  2075.                 }
  2076.                 case URL_BASED: {
  2077.                     Optional<Proprieta> prop = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.PATTERN.equals(p.getNome())).findAny();
  2078.                     if (prop.isPresent()) authnPrincipal.setPattern(prop.get().getValore());
  2079.                     break;
  2080.                 }
  2081.                 case TOKEN: {
  2082.                     Optional<Proprieta> prop = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.TOKEN_CLAIM.equals(p.getNome())).findAny();
  2083.                     if (prop.isPresent()) {
  2084.                         if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_SUBJECT.equals(prop.get().getValore())) {
  2085.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.SUBJECT);
  2086.                         }
  2087.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CLIENT_ID.equals(prop.get().getValore())) {
  2088.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.CLIENTID);
  2089.                         }
  2090.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_USERNAME.equals(prop.get().getValore())) {
  2091.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.USERNAME);
  2092.                         }
  2093.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_EMAIL.equals(prop.get().getValore())) {
  2094.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.EMAIL);
  2095.                         }
  2096.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CUSTOM.equals(prop.get().getValore())) {
  2097.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.CUSTOM);
  2098.                             
  2099.                             Optional<Proprieta> propName = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.NOME.equals(p.getNome())).findAny();
  2100.                             if (propName.isPresent()) authnPrincipal.setNome(propName.get().getValore());
  2101.                         }
  2102.                     }
  2103.                     break;
  2104.                 }
  2105.                 }   // switch config.getTipo
  2106.                 
  2107.                 // IsForward
  2108.                 Optional<Proprieta> prop = pa.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL.equals(p.getNome())).findAny();
  2109.                 if (prop.isPresent() && ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL_TRUE.equals(prop.get().getValore()))
  2110.                     authnPrincipal.setForward(false);
  2111.                 else
  2112.                     authnPrincipal.setForward(true);
  2113.                 
  2114.                 break;
  2115.             }  // case principal
  2116.             
  2117.             case API_KEY: {
  2118.                 
  2119.                 APIImplAutenticazioneApiKey authnApiKey = new APIImplAutenticazioneApiKey();
  2120.                 authnApiKey.setTipo(tipoAutenticazione);
  2121.                 authnApiKey.setOpzionale(Helper.statoFunzionalitaConfToBool( pa.getAutenticazioneOpzionale() ));
  2122.                 autRet = authnApiKey;
  2123.             
  2124.                 if(pa.getProprietaAutenticazioneList()!=null && pa.sizeProprietaAutenticazioneList()>0) {
  2125.                     
  2126.                     APIImplAutenticazioneApiKeyPosizione posizione = null;
  2127.                     APIImplAutenticazioneApiKeyConfig apiKeyNomi = null;
  2128.                     APIImplAutenticazioneApiKeyConfig appIdNomi = null;
  2129.                     boolean useOasNames = false;
  2130.                     
  2131.                     for (Proprieta proprieta : pa.getProprietaAutenticazioneList()) {
  2132.                         String nomeP = proprieta.getNome();
  2133.                         String valoreP = proprieta.getValore();
  2134.                         if(ParametriAutenticazioneApiKey.APP_ID.equals(nomeP)) {
  2135.                             authnApiKey.setAppId(ParametriAutenticazioneApiKey.APP_ID_TRUE.equals(valoreP));
  2136.                         }
  2137.                         else if(ParametriAutenticazioneApiKey.QUERY_PARAMETER.equals(nomeP)) {
  2138.                             if(posizione==null) {
  2139.                                 posizione = new APIImplAutenticazioneApiKeyPosizione();
  2140.                             }
  2141.                             posizione.setQueryParameter(ParametriAutenticazioneApiKey.QUERY_PARAMETER_TRUE.equals(valoreP));
  2142.                         }
  2143.                         else if(ParametriAutenticazioneApiKey.HEADER.equals(nomeP)) {
  2144.                             if(posizione==null) {
  2145.                                 posizione = new APIImplAutenticazioneApiKeyPosizione();
  2146.                             }
  2147.                             posizione.setHeader(ParametriAutenticazioneApiKey.HEADER_TRUE.equals(valoreP));
  2148.                         }
  2149.                         else if(ParametriAutenticazioneApiKey.COOKIE.equals(nomeP)) {
  2150.                             if(posizione==null) {
  2151.                                 posizione = new APIImplAutenticazioneApiKeyPosizione();
  2152.                             }
  2153.                             posizione.setCookie(ParametriAutenticazioneApiKey.COOKIE_TRUE.equals(valoreP));
  2154.                         }
  2155.                         else if(ParametriAutenticazioneApiKey.USE_OAS3_NAMES.equals(nomeP)) {
  2156.                             useOasNames = ParametriAutenticazioneApiKey.USE_OAS3_NAMES_TRUE.equals(valoreP);
  2157.                         }   
  2158.                         else if(ParametriAutenticazioneApiKey.CLEAN_API_KEY.equals(nomeP)) {
  2159.                             boolean clean = ParametriAutenticazioneApiKey.CLEAN_API_KEY_TRUE.equals(valoreP);
  2160.                             authnApiKey.setApiKeyForward(!clean);
  2161.                         }
  2162.                         else if(ParametriAutenticazioneApiKey.CLEAN_APP_ID.equals(nomeP)) {
  2163.                             boolean clean = ParametriAutenticazioneApiKey.CLEAN_APP_ID_TRUE.equals(valoreP);
  2164.                             authnApiKey.setAppIdForward(!clean);
  2165.                         }
  2166.                     }
  2167.                     
  2168.                     if(!useOasNames) {
  2169.                         for (Proprieta proprieta : pa.getProprietaAutenticazioneList()) {
  2170.                             String nomeP = proprieta.getNome();
  2171.                             String valoreP = proprieta.getValore();
  2172.                             if(ParametriAutenticazioneApiKey.NOME_QUERY_PARAMETER_API_KEY.equals(nomeP)) {
  2173.                                 if(apiKeyNomi==null) {
  2174.                                     apiKeyNomi = new APIImplAutenticazioneApiKeyConfig();
  2175.                                 }
  2176.                                 apiKeyNomi.setQueryParameter(valoreP);
  2177.                             }
  2178.                             else if(ParametriAutenticazioneApiKey.NOME_HEADER_API_KEY.equals(nomeP)) {
  2179.                                 if(apiKeyNomi==null) {
  2180.                                     apiKeyNomi = new APIImplAutenticazioneApiKeyConfig();
  2181.                                 }
  2182.                                 apiKeyNomi.setHeader(valoreP);
  2183.                             }
  2184.                             else if(ParametriAutenticazioneApiKey.NOME_COOKIE_API_KEY.equals(nomeP)) {
  2185.                                 if(apiKeyNomi==null) {
  2186.                                     apiKeyNomi = new APIImplAutenticazioneApiKeyConfig();
  2187.                                 }
  2188.                                 apiKeyNomi.setCookie(valoreP);
  2189.                             }
  2190.                             else if(ParametriAutenticazioneApiKey.NOME_QUERY_PARAMETER_APP_ID.equals(nomeP)) {
  2191.                                 if(appIdNomi==null) {
  2192.                                     appIdNomi = new APIImplAutenticazioneApiKeyConfig();
  2193.                                 }
  2194.                                 appIdNomi.setQueryParameter(valoreP);
  2195.                             }
  2196.                             else if(ParametriAutenticazioneApiKey.NOME_HEADER_APP_ID.equals(nomeP)) {
  2197.                                 if(appIdNomi==null) {
  2198.                                     appIdNomi = new APIImplAutenticazioneApiKeyConfig();
  2199.                                 }
  2200.                                 appIdNomi.setHeader(valoreP);
  2201.                             }
  2202.                             else if(ParametriAutenticazioneApiKey.NOME_COOKIE_APP_ID.equals(nomeP)) {
  2203.                                 if(appIdNomi==null) {
  2204.                                     appIdNomi = new APIImplAutenticazioneApiKeyConfig();
  2205.                                 }
  2206.                                 appIdNomi.setCookie(valoreP);
  2207.                             }
  2208.                         }
  2209.                     }
  2210.                     
  2211.                     authnApiKey.setPosizione(posizione);
  2212.                     authnApiKey.setApiKeyNomi(apiKeyNomi);
  2213.                     authnApiKey.setAppIdNomi(appIdNomi);
  2214.                 }
  2215.                 
  2216.                 break;
  2217.             }  // case api-key
  2218.             
  2219.             case CUSTOM: {
  2220.                 APIImplAutenticazioneCustom authnCustom = new APIImplAutenticazioneCustom();
  2221.                 authnCustom.setTipo(tipoAutenticazione);
  2222.                 authnCustom.setOpzionale(Helper.statoFunzionalitaConfToBool( pa.getAutenticazioneOpzionale() ));
  2223.                 autRet = authnCustom;
  2224.                 
  2225.                 authnCustom.setNome(pa.getAutenticazione());
  2226.                 
  2227.                 break;
  2228.             }
  2229.             default:
  2230.                 break;
  2231.             }  // switch autRet.getTipo
  2232.             
  2233.             ControlloAccessiAutenticazione ret = new ControlloAccessiAutenticazione();
  2234.             ret.setAutenticazione(autRet);
  2235.             ret.setToken(token);
  2236.             context.getLogger().info("Invocazione completata con successo");
  2237.             return ret;
  2238.      
  2239.         }
  2240.         catch(javax.ws.rs.WebApplicationException e) {
  2241.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2242.             throw e;
  2243.         }
  2244.         catch(Throwable e) {
  2245.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2246.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2247.         }
  2248.     }

  2250.     /**
  2251.      * Restituisce la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  2252.      *
  2253.      * Questa operazione consente di ottenere la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  2254.      *
  2255.      */
  2256.     @Override
  2257.     public ControlloAccessiAutorizzazioneView getErogazioneControlloAccessiAutorizzazione(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2258.         IContext context = this.getContext();
  2259.         try {
  2260.             context.getLogger().info("Invocazione in corso ...");     

  2262.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2263.             context.getLogger().debug("Autorizzazione completata con successo");    
  2264.             

  2266.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2267.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2268.             
  2269.             ControlloAccessiAutorizzazioneView ret = ErogazioniApiHelper.controlloAccessiAutorizzazioneFromPA(pa);
  2270.             
  2271.             return ret;
  2272.      
  2273.         }
  2274.         catch(javax.ws.rs.WebApplicationException e) {
  2275.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2276.             throw e;
  2277.         }
  2278.         catch(Throwable e) {
  2279.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2280.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2281.         }
  2282.     }

  2284.     /**
  2285.      * Restituisce l'elenco degli applicativi autorizzati
  2286.      *
  2287.      * Questa operazione consente di ottenere l'elenco degli applicativi autorizzati
  2288.      *
  2289.      */
  2290.     @Override
  2291.     public ControlloAccessiErogazioneAutorizzazioneApplicativi getErogazioneControlloAccessiAutorizzazioneApplicativi(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2292.         IContext context = this.getContext();
  2293.         try {
  2294.             context.getLogger().info("Invocazione in corso ...");     

  2296.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2297.             context.getLogger().debug("Autorizzazione completata con successo");     
  2298.             
  2299.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2300.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2301.             ControlloAccessiErogazioneAutorizzazioneApplicativi ret = new ControlloAccessiErogazioneAutorizzazioneApplicativi();
  2302.             
  2303.             int idLista = Liste.PORTE_APPLICATIVE_SERVIZIO_APPLICATIVO_AUTORIZZATO;
  2304.             ConsoleSearch ricerca = Helper.setupRicercaPaginata("", -1, 0, idLista);
  2305.             List<PortaApplicativaAutorizzazioneServizioApplicativo> lista = env.paCore.porteAppServiziApplicativiAutorizzatiList(pa.getId(), ricerca);
  2306.             
  2307.             if(lista!=null && !lista.isEmpty()) {
  2308.                 for (PortaApplicativaAutorizzazioneServizioApplicativo portaApplicativaAutorizzazioneServizioApplicativo : lista) {
  2309.                     ControlloAccessiErogazioneAutorizzazioneApplicativo applicativiItem = new ControlloAccessiErogazioneAutorizzazioneApplicativo();
  2310.                     applicativiItem.setApplicativo(portaApplicativaAutorizzazioneServizioApplicativo.getNome());
  2311.                     applicativiItem.setSoggetto(portaApplicativaAutorizzazioneServizioApplicativo.getNomeSoggettoProprietario());
  2312.                     ret.addApplicativiItem(applicativiItem);
  2313.                 }
  2314.             }
  2315.             
  2316.             context.getLogger().info("Invocazione completata con successo");
  2317.             return ret;
  2318.      
  2319.         }
  2320.         catch(javax.ws.rs.WebApplicationException e) {
  2321.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2322.             throw e;
  2323.         }
  2324.         catch(Throwable e) {
  2325.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2326.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2327.         }
  2328.     }
  2329.     
  2330.     /**
  2331.      * Restituisce l'elenco dei soggetti autorizzati
  2332.      *
  2333.      * Questa operazione consente di ottenere l'elenco dei soggetti autorizzati
  2334.      *
  2335.      */
  2336.     @Override
  2337.     public ControlloAccessiAutorizzazioneSoggetti getErogazioneControlloAccessiAutorizzazioneSoggetti(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2338.         IContext context = this.getContext();
  2339.         try {
  2340.             context.getLogger().info("Invocazione in corso ...");     

  2342.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2343.             context.getLogger().debug("Autorizzazione completata con successo");
  2344.             
  2345.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2346.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2347.             
  2348.             ControlloAccessiAutorizzazioneSoggetti ret = new ControlloAccessiAutorizzazioneSoggetti();
  2349.             List<String> soggetti = BaseHelper.evalnull( () -> pa.getSoggetti().getSoggettoList().stream().map( s -> s.getNome()).collect(Collectors.toList()) );
  2350.                     
  2351.             ret.setSoggetti(soggetti);
  2352.         
  2353.             context.getLogger().info("Invocazione completata con successo");
  2354.             return ret;
  2355.  
  2356.         }
  2357.         catch(javax.ws.rs.WebApplicationException e) {
  2358.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2359.             throw e;
  2360.         }
  2361.         catch(Throwable e) {
  2362.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2363.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2364.         }
  2365.     }
  2366.     
  2367.    /**
  2368.      * Restituisce l'elenco degli applicativi token autorizzati
  2369.      *
  2370.      * Questa operazione consente di ottenere l'elenco degli applicativi token autorizzati
  2371.      *
  2372.      */
  2373.     @Override
  2374.     public ControlloAccessiErogazioneAutorizzazioneApplicativi getErogazioneControlloAccessiAutorizzazioneApplicativiToken(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2375.         IContext context = this.getContext();
  2376.         try {
  2377.             context.getLogger().info("Invocazione in corso ...");     

  2379.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2380.             context.getLogger().debug("Autorizzazione completata con successo");     
  2381.                         
  2382.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2383.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2384.             ControlloAccessiErogazioneAutorizzazioneApplicativi ret = new ControlloAccessiErogazioneAutorizzazioneApplicativi();
  2385.             
  2386.             boolean isProfiloModi = env.isProfiloModi();
  2387.             
  2388.             int idLista = isProfiloModi ? Liste.PORTE_APPLICATIVE_SERVIZIO_APPLICATIVO_AUTORIZZATO : Liste.PORTE_APPLICATIVE_TOKEN_SERVIZIO_APPLICATIVO;
  2389.             ConsoleSearch ricerca = Helper.setupRicercaPaginata("", -1, 0, idLista);
  2390.             List<PortaApplicativaAutorizzazioneServizioApplicativo> lista = isProfiloModi ?
  2391.                     env.paCore.porteAppServiziApplicativiAutorizzatiList(pa.getId(), ricerca)
  2392.                     :
  2393.                     env.paCore.porteAppServiziApplicativiAutorizzatiTokenList(pa.getId(), ricerca);
  2394.             
  2395.             if(lista!=null && !lista.isEmpty()) {
  2396.                 for (PortaApplicativaAutorizzazioneServizioApplicativo portaApplicativaAutorizzazioneServizioApplicativo : lista) {
  2397.                     ControlloAccessiErogazioneAutorizzazioneApplicativo applicativiItem = new ControlloAccessiErogazioneAutorizzazioneApplicativo();
  2398.                     applicativiItem.setApplicativo(portaApplicativaAutorizzazioneServizioApplicativo.getNome());
  2399.                     applicativiItem.setSoggetto(portaApplicativaAutorizzazioneServizioApplicativo.getNomeSoggettoProprietario());
  2400.                     ret.addApplicativiItem(applicativiItem);
  2401.                 }
  2402.             }
  2403.             
  2404.             context.getLogger().info("Invocazione completata con successo");
  2405.             return ret;
  2406.         }
  2407.         catch(javax.ws.rs.WebApplicationException e) {
  2408.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2409.             throw e;
  2410.         }
  2411.         catch(Throwable e) {
  2412.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2413.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2414.         }
  2415.     }

  2417.     /**
  2418.      * Restituisce l'elenco dei ruoli autorizzati
  2419.      *
  2420.      * Questa operazione consente di ottenere l'elenco dei ruoli autorizzati
  2421.      *
  2422.      */
  2423.     @Override
  2424.     public ControlloAccessiAutorizzazioneRuoli getErogazioneControlloAccessiAutorizzazioneRuoli(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2425.         IContext context = this.getContext();
  2426.         try {
  2427.             context.getLogger().info("Invocazione in corso ...");     

  2429.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2430.             context.getLogger().debug("Autorizzazione completata con successo");
  2431.             
  2432.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2433.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2434.             final ControlloAccessiAutorizzazioneRuoli ret = new ControlloAccessiAutorizzazioneRuoli(); 
  2435.                         
  2436.             if(pa.getRuoli()!=null && pa.getRuoli().sizeRuoloList()>0) {
  2437.                 ret.setRuoli(BaseHelper.evalnull( () -> pa.getRuoli().getRuoloList().stream().map(Ruolo::getNome).collect(Collectors.toList()) ));
  2438.             }
  2439.         
  2440.             context.getLogger().info("Invocazione completata con successo");
  2441.             return ret;
  2442.      
  2443.         }
  2444.         catch(javax.ws.rs.WebApplicationException e) {
  2445.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2446.             throw e;
  2447.         }
  2448.         catch(Throwable e) {
  2449.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2450.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2451.         }
  2452.     }
  2453.     
  2454.    /**
  2455.      * Restituisce l'elenco dei ruoli token autorizzati
  2456.      *
  2457.      * Questa operazione consente di ottenere l'elenco dei ruoli token autorizzati
  2458.      *
  2459.      */
  2460.     @Override
  2461.     public ControlloAccessiAutorizzazioneRuoli getErogazioneControlloAccessiAutorizzazioneRuoliToken(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2462.         IContext context = this.getContext();
  2463.         try {
  2464.             context.getLogger().info("Invocazione in corso ...");     

  2466.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2467.             context.getLogger().debug("Autorizzazione completata con successo");     
  2468.                         
  2469.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2470.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2471.             final ControlloAccessiAutorizzazioneRuoli ret = new ControlloAccessiAutorizzazioneRuoli(); 
  2472.                         
  2473.             if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null && pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  2474.                 ret.setRuoli(BaseHelper.evalnull( () -> pa.getAutorizzazioneToken().getRuoli().getRuoloList().stream().map(Ruolo::getNome).collect(Collectors.toList()) ));
  2475.             }
  2476.         
  2477.             context.getLogger().info("Invocazione completata con successo");
  2478.             return ret;
  2479.         }
  2480.         catch(javax.ws.rs.WebApplicationException e) {
  2481.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2482.             throw e;
  2483.         }
  2484.         catch(Throwable e) {
  2485.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2486.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2487.         }
  2488.     }

  2490.     /**
  2491.      * Restituisce l'elenco degli scope autorizzati
  2492.      *
  2493.      * Questa operazione consente di ottenere l'elenco degli scope autorizzati
  2494.      *
  2495.      */
  2496.     @Override
  2497.     public ControlloAccessiAutorizzazioneScopes getErogazioneControlloAccessiAutorizzazioneScope(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2498.         IContext context = this.getContext();
  2499.         try {
  2500.             context.getLogger().info("Invocazione in corso ...");     

  2502.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2503.             context.getLogger().debug("Autorizzazione completata con successo");     

  2505.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2506.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);   
  2507.             final ControlloAccessiAutorizzazioneScopes ret = new ControlloAccessiAutorizzazioneScopes();
  2508.             
  2509.             ret.setScope(BaseHelper.evalnull( () -> pa.getScope().getScopeList().stream().map(Scope::getNome).collect(Collectors.toList()) ));
  2510.             
  2511.             context.getLogger().info("Invocazione completata con successo");
  2512.             return ret;
  2513.      
  2514.         }
  2515.         catch(javax.ws.rs.WebApplicationException e) {
  2516.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2517.             throw e;
  2518.         }
  2519.         catch(Throwable e) {
  2520.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2521.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2522.         }
  2523.     }
  2524.     
  2525.     /**
  2526.      * Restituisce la configurazione relativa alla gestione dei token per quanto concerne il controllo degli accessi
  2527.      *
  2528.      * Questa operazione consente di ottenere la configurazione relativa alla gestione dei token per quanto concerne il controllo degli accessi
  2529.      *
  2530.      */
  2531.     @Override
  2532.     public ControlloAccessiGestioneToken getErogazioneControlloAccessiGestioneToken(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2533.         IContext context = this.getContext();
  2534.         try {
  2535.             context.getLogger().info("Invocazione in corso ...");     

  2537.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2538.             context.getLogger().debug("Autorizzazione completata con successo");
  2539.         
  2540.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2541.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);   
  2542.             
  2543.             final ControlloAccessiGestioneToken ret = new ControlloAccessiGestioneToken();
  2544.             final GestioneToken paToken = pa.getGestioneToken();
  2545.             
  2546.             ret.setAbilitato(paToken != null);
  2547.             if (paToken != null) {
  2548.                 ret.setIntrospection(StatoFunzionalitaConWarningEnum.fromValue(paToken.getIntrospection().getValue()));
  2549.                 ret.setPolicy(paToken.getPolicy());
  2550.                 ret.setTokenForward( Helper.statoFunzionalitaConfToBool( paToken.getForward() ));
  2551.                 ret.setTokenOpzionale( Helper.statoFunzionalitaConfToBool( paToken.getTokenOpzionale() ));
  2552.                 ret.setUserInfo(StatoFunzionalitaConWarningEnum.fromValue( paToken.getUserInfo().getValue() ));
  2553.                 ret.setValidazioneJwt(StatoFunzionalitaConWarningEnum.fromValue( paToken.getValidazione().getValue() ));
  2554.             }
  2555.         
  2556.             context.getLogger().info("Invocazione completata con successo");
  2557.             return ret;
  2558.      
  2559.         }
  2560.         catch(javax.ws.rs.WebApplicationException e) {
  2561.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2562.             throw e;
  2563.         }
  2564.         catch(Throwable e) {
  2565.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2566.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2567.         }
  2568.     }

  2570.    /**
  2571.      * Restituisce la configurazione relativa all'identificazione degli attributi per quanto concerne il controllo degli accessi
  2572.      *
  2573.      * Questa operazione consente di ottenere la configurazione relativa all'identificazione degli attributi per quanto concerne il controllo degli accessi
  2574.      *
  2575.      */
  2576.     @Override
  2577.     public ControlloAccessiIdentificazioneAttributi getErogazioneControlloAccessiIdentificazioneAttributi(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2578.         IContext context = this.getContext();
  2579.         try {
  2580.             context.getLogger().info("Invocazione in corso ...");     

  2582.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2583.             context.getLogger().debug("Autorizzazione completata con successo");     
  2584.                         
  2585.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2586.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2587.         
  2588.             final ControlloAccessiIdentificazioneAttributi ret = new ControlloAccessiIdentificazioneAttributi();
  2589.             if(pa.sizeAttributeAuthorityList()>0) {
  2590.                 ret.setAbilitato(true);
  2591.                 ret.setAttributeAuthority(new ArrayList<ControlloAccessiAttributeAuthority>());
  2592.                 for (AttributeAuthority aa : pa.getAttributeAuthorityList()) {
  2593.                     ControlloAccessiAttributeAuthority attributeAuthorityItem = new ControlloAccessiAttributeAuthority();
  2594.                     attributeAuthorityItem.setNome(aa.getNome());
  2595.                     if(aa.sizeAttributoList()>0) {
  2596.                         attributeAuthorityItem.setAttributi(new ArrayList<>());
  2597.                         for (String attributeName : aa.getAttributoList()) {
  2598.                             attributeAuthorityItem.addAttributiItem(attributeName);
  2599.                         }
  2600.                     }
  2601.                     ret.addAttributeAuthorityItem(attributeAuthorityItem);
  2602.                 }
  2603.             }
  2604.             else {
  2605.                 ret.setAbilitato(false);
  2606.             }

  2608.             context.getLogger().info("Invocazione completata con successo");
  2609.             return ret;
  2610.         }
  2611.         catch(javax.ws.rs.WebApplicationException e) {
  2612.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2613.             throw e;
  2614.         }
  2615.         catch(Throwable e) {
  2616.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2617.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2618.         }
  2619.     }
  2620.     
  2621.     /**
  2622.      * Restituisce le proprietà di configurazione attivate
  2623.      *
  2624.      * Questa operazione consente di ottenere le proprietà di configurazione
  2625.      *
  2626.      */
  2627.     @Override
  2628.     public ElencoProprieta getErogazioneElencoProprieta(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2629.         IContext context = this.getContext();
  2630.         try {
  2631.             context.getLogger().info("Invocazione in corso ...");     

  2633.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2634.             context.getLogger().debug("Autorizzazione completata con successo");     
  2635.                         
  2636.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  2637.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  2638.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  2639.             
  2640.             final IDPortaApplicativa idPa = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPADefault( idAsps, env.apsCore ),  "Gruppo default per l'erogazione scelta" );
  2641.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPa);
  2642.      
  2643.             ElencoProprieta ret = new ElencoProprieta();
  2644.             ret.setProprieta(new ArrayList<>());
  2645.             if(pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  2646.                 for (Proprieta p: pa.getProprietaList()) {
  2647.                     org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura retP = new org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura();
  2648.                     retP.setNome(p.getNome());
  2649.                     retP.setValore(p.getValore());
  2650.                     retP.setEncrypted(BYOKUtilities.isWrappedValue(p.getValore()));
  2651.                     ret.addProprietaItem(retP);
  2652.                 }
  2653.             }
  2654.             
  2655.             context.getLogger().info("Invocazione completata con successo");
  2656.             return ret;        
  2657.         }
  2658.         catch(javax.ws.rs.WebApplicationException e) {
  2659.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2660.             throw e;
  2661.         }
  2662.         catch(Throwable e) {
  2663.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2664.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2665.         }
  2666.     }

  2668.     /**
  2669.      * Restituisce il dettaglio di una proprietà di configurazione
  2670.      *
  2671.      * Questa operazione consente di ottenere il dettaglio di una proprietà di configurazione
  2672.      *
  2673.      */
  2674.     @Override
  2675.     public org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura getErogazioneProprieta(String nome, Integer versione, String proprieta, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2676.         IContext context = this.getContext();
  2677.         try {
  2678.             context.getLogger().info("Invocazione in corso ...");     

  2680.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2681.             context.getLogger().debug("Autorizzazione completata con successo");     
  2682.                         
  2683.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  2684.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  2685.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  2686.             
  2687.             final IDPortaApplicativa idPa = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPADefault( idAsps, env.apsCore ),  "Gruppo default per l'erogazione scelta" );
  2688.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPa);
  2689.             
  2690.             Proprieta toGet = null;
  2691.             if(pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  2692.                 Optional<Proprieta> op = BaseHelper.findFirst(pa.getProprietaList(), p -> p.getNome().equals(proprieta));
  2693.                 if(op.isPresent()) {
  2694.                     toGet = op.get();
  2695.                 }
  2696.             }
  2697.             
  2698.             org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura ret = null;
  2699.             if(toGet!=null) {
  2700.                 ret = new org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura();
  2701.                 ret.setNome(toGet.getNome());
  2702.                 ret.setValore(toGet.getValore());
  2703.                 ret.setEncrypted(BYOKUtilities.isWrappedValue(toGet.getValore()));
  2704.             }
  2705.             else {
  2706.                 throw FaultCode.NOT_FOUND.toException("Nessuna proprietà è presente nella configurazione con nome '"+proprieta+"'"); 
  2707.             }
  2708.             
  2709.             context.getLogger().info("Invocazione completata con successo");
  2710.             return ret;
  2711.      
  2712.         }
  2713.         catch(javax.ws.rs.WebApplicationException e) {
  2714.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2715.             throw e;
  2716.         }
  2717.         catch(Throwable e) {
  2718.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2719.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2720.         }
  2721.     }

  2723.     /**
  2724.      * Restituisce le informazioni sulla configurazione CORS associata all'erogazione
  2725.      *
  2726.      * Questa operazione consente di ottenere le informazioni sulla configurazione CORS associata all'erogazione identificata dal nome e dalla versione
  2727.      *
  2728.      */
  2729.     @Override
  2730.     public GestioneCors getErogazioneGestioneCORS(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  2731.         IContext context = this.getContext();
  2732.         try {
  2733.             context.getLogger().info("Invocazione in corso ...");     

  2735.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2736.             context.getLogger().debug("Autorizzazione completata con successo");     
  2737.                         
  2738.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  2739.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  2740.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  2741.             
  2742.             final IDPortaApplicativa idPa = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPADefault( idAsps, env.apsCore ),  "Gruppo default per l'erogazione scelta" );
  2743.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPa);
  2744.             final CorsConfigurazione paConf = pa.getGestioneCors();
  2745.             
  2746.             final GestioneCors ret = ErogazioniApiHelper.convert(paConf);
  2747.             
  2748.             context.getLogger().info("Invocazione completata con successo");
  2749.             return ret;

  2751.         }
  2752.         catch(javax.ws.rs.WebApplicationException e) {
  2753.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2754.             throw e;
  2755.         }
  2756.         catch(Throwable e) {
  2757.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2758.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2759.         }
  2760.     }
  2761.     
  2762.     /**
  2763.      * Restituisce il dettaglio di una policy di rate limiting
  2764.      *
  2765.      * Questa operazione consente di ottenere il dettaglio di una policy di rate limiting
  2766.      *
  2767.      */
  2768.     @Override
  2769.     public RateLimitingPolicyErogazioneView getErogazioneRateLimitingPolicy(String nome, Integer versione, String idPolicy, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2770.         IContext context = this.getContext();
  2771.         try {
  2772.             context.getLogger().info("Invocazione in corso ...");     

  2774.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2775.             context.getLogger().debug("Autorizzazione completata con successo");
  2776.             
  2777.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2778.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2779.             
  2780.             AttivazionePolicy policy = BaseHelper.supplyOrNotFound( 
  2781.                     () -> env.confCore.getAttivazionePolicy(idPolicy, RuoloPolicy.APPLICATIVA, pa.getNome()),
  2782.                     "Rate Limiting Policy con nome " + idPolicy
  2783.                 );
  2784.             if ( policy == null ) 
  2785.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting con nome " + idPolicy );
  2786.             
  2787.             InfoPolicy infoPolicy = env.confCore.getInfoPolicy(policy.getIdPolicy());
  2788.                         
  2789.             RateLimitingPolicyErogazioneView ret = ErogazioniApiHelper.convert(policy, infoPolicy, new RateLimitingPolicyErogazioneView());
  2790.             
  2791.             context.getLogger().info("Invocazione completata con successo");
  2792.             return ret;
  2793.      
  2794.         }
  2795.         catch(javax.ws.rs.WebApplicationException e) {
  2796.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2797.             throw e;
  2798.         }
  2799.         catch(Throwable e) {
  2800.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2801.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2802.         }
  2803.     }
  2804.     
  2805.     /**
  2806.      * Restituisce la configurazione relativa alla registrazione dei diagnostici
  2807.      *
  2808.      * Questa operazione consente di ottenere la configurazione relativa alla registrazione dei diagnostici
  2809.      *
  2810.      */
  2811.     @Override
  2812.     public RegistrazioneDiagnosticiConfigurazione getErogazioneRegistrazioneDiagnostici(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2813.         IContext context = this.getContext();
  2814.         try {
  2815.             context.getLogger().info("Invocazione in corso ...");     

  2817.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2818.             context.getLogger().debug("Autorizzazione completata con successo");     
  2819.                         

  2821.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2822.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);   
  2823.             final RegistrazioneDiagnosticiConfigurazione ret = ErogazioniApiHelper.fromDiagnosticiConfigurazione(pa.getTracciamento());
  2824.             
  2825.             context.getLogger().info("Invocazione completata con successo");
  2826.             return ret;
  2827.      
  2828.         }
  2829.         catch(javax.ws.rs.WebApplicationException e) {
  2830.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2831.             throw e;
  2832.         }
  2833.         catch(Throwable e) {
  2834.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2835.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2836.         }
  2837.     }

  2839.     /**
  2840.      * Restituisce la configurazione relativa alla registrazione dei messaggi
  2841.      *
  2842.      * Questa operazione consente di ottenere la configurazione relativa alla registrazione dei messaggi
  2843.      *
  2844.      */
  2845.     @Override
  2846.     public RegistrazioneMessaggi getErogazioneRegistrazioneMessaggi(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2847.         IContext context = this.getContext();
  2848.         try {
  2849.             context.getLogger().info("Invocazione in corso ...");     

  2851.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2852.             context.getLogger().debug("Autorizzazione completata con successo");
  2853.             
  2854.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2855.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);   
  2856.             final RegistrazioneMessaggi ret = ErogazioniApiHelper.fromDumpConfigurazione(pa.getDump());
  2857.             
  2858.             context.getLogger().info("Invocazione completata con successo");
  2859.             return ret;
  2860.      
  2861.         }
  2862.         catch(javax.ws.rs.WebApplicationException e) {
  2863.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2864.             throw e;
  2865.         }
  2866.         catch(Throwable e) {
  2867.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2868.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2869.         }
  2870.     }

  2872.     
  2873.     /**
  2874.      * Restituisce la configurazione relativa alla registrazione delle transazioni
  2875.      *
  2876.      * Questa operazione consente di ottenere la configurazione relativa alla registrazione delle transazioni
  2877.      *
  2878.      */
  2879.     @Override
  2880.     public RegistrazioneTransazioniConfigurazione getErogazioneRegistrazioneTransazioni(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2881.         IContext context = this.getContext();
  2882.         try {
  2883.             context.getLogger().info("Invocazione in corso ...");     

  2885.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2886.             context.getLogger().debug("Autorizzazione completata con successo");     
  2887.                         
  2888.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2889.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);   
  2890.             final RegistrazioneTransazioniConfigurazione ret = ErogazioniApiHelper.fromTransazioniConfigurazione(pa.getTracciamento(), env);
  2891.         
  2892.             context.getLogger().info("Invocazione completata con successo");
  2893.             return ret;
  2894.      
  2895.         }
  2896.         catch(javax.ws.rs.WebApplicationException e) {
  2897.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2898.             throw e;
  2899.         }
  2900.         catch(Throwable e) {
  2901.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2902.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2903.         }
  2904.     }

  2906.     /**
  2907.      * Restituisce l'indicazione sullo stato del gruppo
  2908.      *
  2909.      * Questa operazione consente di ottenere lo stato attuale del gruppo
  2910.      *
  2911.      */
  2912.     @Override
  2913.     public ApiImplStato getErogazioneStato(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2914.         IContext context = this.getContext();
  2915.         try {
  2916.             context.getLogger().info("Invocazione in corso ...");     

  2918.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2919.             context.getLogger().debug("Autorizzazione completata con successo");
  2920.         
  2921.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2922.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2923.             
  2924.             final ApiImplStato ret = new ApiImplStato();
  2925.             ret.setAbilitato(Helper.statoFunzionalitaConfToBool(pa.getStato()));
  2926.                         
  2927.         
  2928.             context.getLogger().info("Invocazione completata con successo");
  2929.             return ret;
  2930.      
  2931.         }
  2932.         catch(javax.ws.rs.WebApplicationException e) {
  2933.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2934.             throw e;
  2935.         }
  2936.         catch(Throwable e) {
  2937.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2938.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2939.         }
  2940.     }
  2941.     
  2942.     /**
  2943.      * Restituisce il dettaglio di una regola di correlazione applicativa per la richiesta
  2944.      *
  2945.      * Questa operazione consente di ottenere il dettaglio di una regola di correlazione applicativa per la richiesta
  2946.      *
  2947.      */
  2948.     @Override
  2949.     public CorrelazioneApplicativaRichiesta getErogazioneTracciamentoCorrelazioneApplicativaRichiesta(String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2950.         IContext context = this.getContext();
  2951.         try {
  2952.             context.getLogger().info("Invocazione in corso ...");     

  2954.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2955.             context.getLogger().debug("Autorizzazione completata con successo");     
  2956.             
  2957.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  2958.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  2959.             
  2960.             final String searchElemento = elemento.equals("*")
  2961.                     ? ""
  2962.                     : elemento;         
  2963.             List<CorrelazioneApplicativaElemento> lista = BaseHelper.evalnull( () -> pa.getCorrelazioneApplicativa().getElementoList() );
  2964.             
  2965.             Optional<CorrelazioneApplicativaElemento> el = BaseHelper.findFirst( lista, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento) );
  2966.             
  2967.             if ( !el.isPresent() )
  2968.                 throw FaultCode.NOT_FOUND.toException("CorrelazioneApplicativaRichiesta per l'elemento " + elemento + " non presente");
  2969.             
  2970.             CorrelazioneApplicativaRichiesta ret = ErogazioniApiHelper.convert(el.get());
  2971.             
  2972.             context.getLogger().info("Invocazione completata con successo");
  2973.             return ret;
  2974.      
  2975.         }
  2976.         catch(javax.ws.rs.WebApplicationException e) {
  2977.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2978.             throw e;
  2979.         }
  2980.         catch(Throwable e) {
  2981.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2982.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2983.         }
  2984.     }
  2985.     
  2986.     /**
  2987.      * Restituisce il dettaglio di una regola di correlazione applicativa per la risposta
  2988.      *
  2989.      * Questa operazione consente di ottenere il dettaglio di una regola di correlazione applicativa per la risposta
  2990.      *
  2991.      */
  2992.     @Override
  2993.     public CorrelazioneApplicativaRisposta getErogazioneTracciamentoCorrelazioneApplicativaRisposta(String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2994.         IContext context = this.getContext();
  2995.         try {
  2996.             context.getLogger().info("Invocazione in corso ...");     

  2998.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2999.             context.getLogger().debug("Autorizzazione completata con successo");    
  3000.             
  3001.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3002.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3003.             
  3004.             final String searchElemento = elemento.equals("*")
  3005.                     ? ""
  3006.                     : elemento;         
  3007.             
  3008.             List<CorrelazioneApplicativaRispostaElemento> lista = BaseHelper.evalnull( () -> pa.getCorrelazioneApplicativaRisposta().getElementoList() );
  3009.             
  3010.             Optional<CorrelazioneApplicativaRispostaElemento> el = BaseHelper.findFirst( lista, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento) );
  3011.             
  3012.             if ( !el.isPresent() )
  3013.                 throw FaultCode.NOT_FOUND.toException("CorrelazioneApplicativaRisposta per l'elemento " + elemento + " non presente");
  3014.             
  3015.             CorrelazioneApplicativaRisposta ret = ErogazioniApiHelper.convert(el.get());
  3016.             
  3017.             context.getLogger().info("Invocazione completata con successo");
  3018.             return ret;
  3019.      
  3020.         }
  3021.         catch(javax.ws.rs.WebApplicationException e) {
  3022.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3023.             throw e;
  3024.         }
  3025.         catch(Throwable e) {
  3026.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3027.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3028.         }
  3029.     }
  3030.     
  3031.     /**
  3032.      * Restituisce la configurazione relativa alla validazione dei contenuti applicativi
  3033.      *
  3034.      * Questa operazione consente di ottenere la configurazione relativa alla validazione dei contenuti applicativi
  3035.      *
  3036.      */
  3037.     @Override
  3038.     public Validazione getErogazioneValidazione(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3039.         IContext context = this.getContext();
  3040.         try {
  3041.             context.getLogger().info("Invocazione in corso ...");     

  3043.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3044.             context.getLogger().debug("Autorizzazione completata con successo");     
  3045.             
  3046.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3047.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3048.             final Validazione ret = ErogazioniApiHelper.fromValidazioneContenutiApplicativi(pa.getValidazioneContenutiApplicativi());
  3049.         
  3050.             context.getLogger().info("Invocazione completata con successo");
  3051.             return ret;
  3052.      
  3053.         }
  3054.         catch(javax.ws.rs.WebApplicationException e) {
  3055.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3056.             throw e;
  3057.         }
  3058.         catch(Throwable e) {
  3059.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3060.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3061.         }
  3062.     }
  3063.     
  3064.     /**
  3065.      * Consente di modificare la configurazione relativa al caching delle risposte
  3066.      *
  3067.      * Questa operazione consente di aggiornare la configurazione relativa al caching delle risposte
  3068.      *
  3069.      */
  3070.     @Override
  3071.     public void updateErogazioneCachingRisposta(CachingRisposta body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3072.         IContext context = this.getContext();
  3073.         try {
  3074.             context.getLogger().info("Invocazione in corso ...");     

  3076.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3077.             context.getLogger().debug("Autorizzazione completata con successo");
  3078.             
  3079.             BaseHelper.throwIfNull(body);
  3080.             
  3081.             // Così prendi le impostazioni di default.
  3082.             //  Configurazione configurazione = confCore.getConfigurazioneGenerale();
  3083.             //  ResponseCachingConfigurazioneGenerale responseCachingGenerale = configurazione.getResponseCaching();
  3084.             //  responseCachingGenerale.getConfigurazione();        
  3085.             
  3086.             if (body.isMaxResponseSize()) {
  3087.                 if (body.getMaxResponseSizeKb() == null)
  3088.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Devi specificare il campo MaxResponseSizeKb");
  3089.             }
  3090.             
  3091.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3092.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3093.         
  3094.             if (!env.paHelper.checkDataConfigurazioneResponseCachingPorta(TipoOperazione.OTHER, true, body.getStato().toString())) {
  3095.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3096.             }
  3097.             
  3098.             ResponseCachingConfigurazione newConfigurazione = ErogazioniApiHelper.buildResponseCachingConfigurazione(body, env.paHelper);
  3099.             
  3100.             pa.setResponseCaching(newConfigurazione);
  3101.             env.paCore.performUpdateOperation(env.userLogin, false, pa);            
  3102.             
  3103.             context.getLogger().info("Invocazione completata con successo");
  3104.      
  3105.         }
  3106.         catch(javax.ws.rs.WebApplicationException e) {
  3107.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3108.             throw e;
  3109.         }
  3110.         catch(Throwable e) {
  3111.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3112.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3113.         }
  3114.     }

  3116.     /**
  3117.      * Consente di modificare il canale associato all'erogazione
  3118.      *
  3119.      * Questa operazione consente di aggiornare il canale associato all'erogazione
  3120.      *
  3121.      */
  3122.     @Override
  3123.     public void updateErogazioneCanale(ConfigurazioneApiCanale body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  3124.         IContext context = this.getContext();
  3125.         try {
  3126.             context.getLogger().info("Invocazione in corso ...");     

  3128.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3129.             context.getLogger().debug("Autorizzazione completata con successo");     
  3130.                         
  3131.             BaseHelper.throwIfNull(body);

  3133.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  3134.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  3135.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  3136.             
  3137.             final IDPortaApplicativa idPa = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPADefault( idAsps, env.apsCore ),  "Gruppo default per l'erogazione scelta" );
  3138.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPa);
  3139.                         
  3140.             if(ConfigurazioneCanaleEnum.RIDEFINITO.equals(body.getConfigurazione())){
  3141.                 if(body.getCanale()==null || "".equals(body.getCanale())) {
  3142.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un canale");
  3143.                 }
  3144.                 if(!env.canali.contains(body.getCanale())) {
  3145.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il canale fornito '" + body.getCanale() + "' non è presente nel registro");
  3146.                 }
  3147.                 pa.setCanale(body.getCanale());
  3148.             }
  3149.             else {
  3150.                 pa.setCanale(null);
  3151.             }
  3152.             
  3153.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3154.             
  3155.             context.getLogger().info("Invocazione completata con successo");
  3156.      
  3157.         }
  3158.         catch(javax.ws.rs.WebApplicationException e) {
  3159.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3160.             throw e;
  3161.         }
  3162.         catch(Throwable e) {
  3163.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3164.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3165.         }
  3166.     }

  3168.     /**
  3169.      * Consente di modificare la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  3170.      *
  3171.      * Questa operazione consente di aggiornare la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  3172.      *
  3173.      */
  3174.     @Override
  3175.     public void updateErogazioneControlloAccessiAutenticazione(ControlloAccessiAutenticazione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3176.         IContext context = this.getContext();
  3177.         try {
  3178.             context.getLogger().info("Invocazione in corso ...");     

  3180.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3181.             context.getLogger().debug("Autorizzazione completata con successo");
  3182.             
  3183.             BaseHelper.throwIfNull(body);
  3184.             
  3185.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3186.             final PortaApplicativa newPa = env.paCore.getPortaApplicativa(env.idPa);
  3187.             final PortaApplicativa oldPa = env.paCore.getPortaApplicativa(env.idPa);            

  3189.             ErogazioniApiHelper.fillPortaApplicativa(env, body, newPa);
  3190.             
  3191.             if (! ErogazioniApiHelper.controlloAccessiCheckPA(env, oldPa, newPa)) {
  3192.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  3193.             }
  3194.         
  3195.             env.paCore.performUpdateOperation(env.userLogin, false, newPa);
  3196.         
  3197.             context.getLogger().info("Invocazione completata con successo");
  3198.      
  3199.         }
  3200.         catch(javax.ws.rs.WebApplicationException e) {
  3201.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3202.             throw e;
  3203.         }
  3204.         catch(Throwable e) {
  3205.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3206.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3207.         }
  3208.     }

  3210.     /**
  3211.      * Consente di modificare la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  3212.      *
  3213.      * Questa operazione consente di aggiornare la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  3214.      *
  3215.      */
  3216.     @Override
  3217.     public void updateErogazioneControlloAccessiAutorizzazione(ControlloAccessiAutorizzazione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3218.         IContext context = this.getContext();
  3219.         try {
  3220.             context.getLogger().info("Invocazione in corso ...");     

  3222.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3223.             context.getLogger().debug("Autorizzazione completata con successo");
  3224.             
  3225.             BaseHelper.throwIfNull(body);
  3226.             
  3227.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3228.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);                   
  3229.             final PortaApplicativa newPa = env.paCore.getPortaApplicativa(env.idPa);        
  3230.             
  3231.             ErogazioniApiHelper.fillPortaApplicativa(body, newPa);
  3232.             
  3233.             if (!ErogazioniApiHelper.controlloAccessiCheckPA(env, pa, newPa)) {
  3234.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  3235.             }
  3236.             
  3237.             env.paCore.performUpdateOperation(env.userLogin, false, newPa);
  3238.                         
  3239.             context.getLogger().info("Invocazione completata con successo");
  3240.      
  3241.         }
  3242.         catch(javax.ws.rs.WebApplicationException e) {
  3243.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3244.             throw e;
  3245.         }
  3246.         catch(Throwable e) {
  3247.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3248.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3249.         }
  3250.     }

  3252.     /**
  3253.      * Consente di modificare la configurazione relativa alla gestione dei token per quanto concerne il controllo degli accessi
  3254.      *
  3255.      * Questa operazione consente di aggiornare la configurazione relativa alla gestione dei token per quanto concerne il controllo degli accessi
  3256.      *
  3257.      */
  3258.     @Override
  3259.     public void updateErogazioneControlloAccessiGestioneToken(ControlloAccessiGestioneToken body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3260.         IContext context = this.getContext();
  3261.         try {
  3262.             context.getLogger().info("Invocazione in corso ...");
  3263.             
  3264.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3265.             context.getLogger().debug("Autorizzazione completata con successo");     
  3266.             
  3267.             BaseHelper.throwIfNull(body);
  3268.             
  3269.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3270.             final PortaApplicativa oldPa = env.paCore.getPortaApplicativa(env.idPa);
  3271.             final PortaApplicativa newPa = env.paCore.getPortaApplicativa(env.idPa);
  3272.             
  3273.             if (body.isAbilitato()) {
  3274.                 GestioneToken gTok = newPa.getGestioneToken() != null ? newPa.getGestioneToken() : new GestioneToken();
  3275.                 ErogazioniApiHelper.fillGestioneToken(gTok, body);
  3276.                 newPa.setGestioneToken(gTok);
  3277.             }
  3278.             else
  3279.                 newPa.setGestioneToken(null);
  3280.             
  3281.             if ( !ErogazioniApiHelper.controlloAccessiCheckPA(env, oldPa, newPa) ) {
  3282.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  3283.             }
  3284.             
  3285.             env.paCore.performUpdateOperation(env.userLogin, false, newPa);
  3286.             
  3287.             context.getLogger().info("Invocazione completata con successo");
  3288.  
  3289.         }
  3290.         catch(javax.ws.rs.WebApplicationException e) {
  3291.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3292.             throw e;
  3293.         }
  3294.         catch(Throwable e) {
  3295.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3296.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3297.         }
  3298.     }
  3299.     
  3300.     /**
  3301.      * Modifica i dati di una proprietà di configurazione
  3302.      *
  3303.      * Questa operazione consente di aggiornare i dati relativi ad una proprietà di configurazione
  3304.      *
  3305.      */
  3306.     @Override
  3307.     public void updateErogazioneProprieta(org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura body, String nome, Integer versione, String proprieta, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {

  3309.         IContext context = this.getContext();
  3310.         try {
  3311.             context.getLogger().info("Invocazione in corso ...");     

  3313.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3314.             context.getLogger().debug("Autorizzazione completata con successo");     
  3315.                         
  3316.             BaseHelper.throwIfNull(body);
  3317.             
  3318.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3319.             if(env.paCore==null) {
  3320.                 throw new CoreException("PaCore not initialized");
  3321.             }
  3322.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3323.             
  3324.             if ((body.getNome().indexOf(" ") != -1) || (body.getValore().indexOf(" ") != -1)) {
  3325.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEI_CAMPI_DI_TESTO);
  3326.             }
  3327.             
  3328.             if(!proprieta.equals(body.getNome()) &&
  3329.                 // cambio nome proprieta
  3330.                 pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  3331.                 for (Proprieta p : pa.getProprietaList()) {
  3332.                     if(p.getNome().equals(body.getNome())) {
  3333.                         throw FaultCode.CONFLITTO.toException("Proprietà " + body.getNome() + " già assegnata alla configurazione");
  3334.                     }
  3335.                 }
  3336.             }
  3337.             
  3338.             boolean found = false;
  3339.             if(pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  3340.                 for (Proprieta p : pa.getProprietaList()) {
  3341.                     if(p.getNome().equals(proprieta)) {
  3342.                         p.setNome(body.getNome());
  3343.                         if(env.paCore!=null && env.paCore.getDriverBYOKUtilities()!=null && 
  3344.                                 body.isEncrypted()!=null && body.isEncrypted().booleanValue()) {
  3345.                             p.setValore(env.paCore.getDriverBYOKUtilities().wrap(body.getValore()));
  3346.                         }
  3347.                         else {
  3348.                             if(body.getValore().length()>255) {
  3349.                                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_VALORE_PROPRIETA_255);
  3350.                             }
  3351.                             p.setValore(body.getValore());
  3352.                         }
  3353.                         found = true;
  3354.                         break;
  3355.                     }
  3356.                 }
  3357.             }
  3358.             
  3359.             if(!found) {
  3360.                 throw FaultCode.NOT_FOUND.toException("Proprietà " + body.getNome() + " non presente nella configurazione");
  3361.             }
  3362.             
  3363.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3364.             
  3365.             context.getLogger().info("Invocazione completata con successo");
  3366.      
  3367.         }
  3368.         catch(javax.ws.rs.WebApplicationException e) {
  3369.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3370.             throw e;
  3371.         }
  3372.         catch(Throwable e) {
  3373.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3374.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3375.         }
  3376.     }

  3378.     /**
  3379.      * Consente di modificare la configurazione relativa all'identificazione degli attributi per quanto concerne il controllo degli accessi
  3380.      *
  3381.      * Questa operazione consente di aggiornare la configurazione relativa all'identificazione degli attributi per quanto concerne il controllo degli accessi
  3382.      *
  3383.      */
  3384.     @Override
  3385.     public void updateErogazioneControlloIdentificazioneAttributi(ControlloAccessiIdentificazioneAttributi body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3386.         IContext context = this.getContext();
  3387.         try {
  3388.             context.getLogger().info("Invocazione in corso ...");     

  3390.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3391.             context.getLogger().debug("Autorizzazione completata con successo");     
  3392.                         
  3393.             BaseHelper.throwIfNull(body);
  3394.             
  3395.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3396.             final PortaApplicativa oldPa = env.paCore.getPortaApplicativa(env.idPa);
  3397.             final PortaApplicativa newPa = env.paCore.getPortaApplicativa(env.idPa);
  3398.         
  3399.             if (body.isAbilitato() && body.getAttributeAuthority()!=null && !body.getAttributeAuthority().isEmpty()) {
  3400.                 if(newPa.getAttributeAuthorityList()==null) {
  3401.                     newPa.setAttributeAuthorityList(new ArrayList<AttributeAuthority>());
  3402.                 }
  3403.                 else {
  3404.                     newPa.getAttributeAuthorityList().clear();
  3405.                 }
  3406.                 for (ControlloAccessiAttributeAuthority controlloAccessiAttributeAuthority : body.getAttributeAuthority()) {
  3407.                     
  3408.                     GenericProperties gp = null;
  3409.                     try {
  3410.                         gp = env.confCore.getGenericProperties(controlloAccessiAttributeAuthority.getNome(), org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, false);
  3411.                     }catch(DriverConfigurazioneNotFound notFound) {}
  3412.                     if(gp==null) {
  3413.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("AttributeAuthority '"+controlloAccessiAttributeAuthority.getNome()+"' non esistente");
  3414.                     }
  3415.                     
  3416.                     AttributeAuthority aa = new AttributeAuthority();
  3417.                     aa.setNome(controlloAccessiAttributeAuthority.getNome());
  3418.                     if(controlloAccessiAttributeAuthority.getAttributi()!=null && !controlloAccessiAttributeAuthority.getAttributi().isEmpty()) {
  3419.                         aa.setAttributoList(controlloAccessiAttributeAuthority.getAttributi());
  3420.                     }
  3421.                     newPa.addAttributeAuthority(aa);
  3422.                 }
  3423.             }
  3424.             else {
  3425.                 if(newPa.getAttributeAuthorityList()!=null) {
  3426.                     newPa.getAttributeAuthorityList().clear();
  3427.                 }
  3428.                 else {
  3429.                     newPa.setAttributeAuthorityList(new ArrayList<AttributeAuthority>());
  3430.                 }
  3431.             }
  3432.             
  3433.             if ( !ErogazioniApiHelper.controlloAccessiCheckPA(env, oldPa, newPa) ) {
  3434.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  3435.             }
  3436.             
  3437.             env.paCore.performUpdateOperation(env.userLogin, false, newPa);
  3438.             
  3439.             context.getLogger().info("Invocazione completata con successo");
  3440.         }
  3441.         catch(javax.ws.rs.WebApplicationException e) {
  3442.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3443.             throw e;
  3444.         }
  3445.         catch(Throwable e) {
  3446.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3447.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3448.         }
  3449.     }

  3451.     /**
  3452.      * Consente di modificare la configurazione CORS associata all'erogazione
  3453.      *
  3454.      * Questa operazione consente di aggiornare la configurazione CORS associata all'erogazione identificata dal nome e dalla versione
  3455.      *
  3456.      */
  3457.     @Override
  3458.     public void updateErogazioneGestioneCORS(GestioneCors body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  3459.         IContext context = this.getContext();
  3460.         try {
  3461.             context.getLogger().info("Invocazione in corso ...");     

  3463.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3464.             context.getLogger().debug("Autorizzazione completata con successo");
  3465.             
  3466.             BaseHelper.throwIfNull(body);

  3468.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  3469.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getServizioIfErogazione(tipoServizio , nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  3470.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  3471.             
  3472.             final IDPortaApplicativa idPa = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPADefault( idAsps, env.apsCore ),  "Gruppo default per l'erogazione scelta" );
  3473.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(idPa);
  3474.             final CorsConfigurazione oldConf = pa.getGestioneCors();
  3475.             
  3476.             
  3477.             if (body.isRidefinito())
  3478.                 pa.setGestioneCors(ErogazioniApiHelper.buildCorsConfigurazione(body, env, oldConf));
  3479.             else
  3480.                 pa.setGestioneCors(null);
  3481.             
  3482.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3483.             
  3484.             context.getLogger().info("Invocazione completata con successo");
  3485.         
  3486.      
  3487.         }
  3488.         catch(javax.ws.rs.WebApplicationException e) {
  3489.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3490.             throw e;
  3491.         }
  3492.         catch(Throwable e) {
  3493.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3494.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3495.         }
  3496.     }
  3497.     
  3498.     /**
  3499.      * Modifica i dati di una policy di rate limiting
  3500.      *
  3501.      * Questa operazione consente di aggiornare i dati relativi ad una policy di rate limiting
  3502.      *
  3503.      */
  3504.     @Override
  3505.     public void updateErogazioneRateLimitingPolicy(RateLimitingPolicyErogazioneUpdate body, String nome, Integer versione, String idPolicy, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3506.         IContext context = this.getContext();
  3507.         try {
  3508.             context.getLogger().info("Invocazione in corso ...");     

  3510.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3511.             context.getLogger().debug("Autorizzazione completata con successo");
  3512.             
  3513.             BaseHelper.throwIfNull(body);            
  3514.             
  3515.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3516.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);       
  3517.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  3518.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  3519.                     "Accordo Servizio Parte Specifica");
  3520.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3521.             
  3522.             AttivazionePolicy policy = BaseHelper.supplyOrNotFound( 
  3523.                     () -> env.confCore.getAttivazionePolicy(idPolicy, RuoloPolicy.APPLICATIVA, pa.getNome()),
  3524.                     "Rate Limiting Policy con nome " + idPolicy
  3525.                 );
  3526.             if ( policy == null ) 
  3527.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting con nome " + idPolicy );
  3528.             InfoPolicy infoPolicy = env.confCore.getInfoPolicy(policy.getIdPolicy());
  3529.         
  3530.             ErogazioniApiHelper.override(infoPolicy.getTipoRisorsa(), body, env.protocolFactory.getProtocol(), env.idSoggetto.toIDSoggetto(), env.requestWrapper);  
  3531.             String errorAttivazione = env.confHelper.readDatiAttivazionePolicyFromHttpParameters(policy, false, TipoOperazione.CHANGE, infoPolicy);
  3532.             if ( !StringUtils.isEmpty(errorAttivazione) ) {
  3533.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(errorAttivazione));
  3534.             }
  3535.             
  3536.             String modalita = ErogazioniApiHelper.getDataElementModalita(infoPolicy.isBuiltIn());
  3537.             ErogazioniApiHelper.attivazionePolicyCheckData(TipoOperazione.CHANGE, pa, policy, infoPolicy, env, env.apcCore.toMessageServiceBinding(apc.getServiceBinding()), modalita);
  3538.             
  3539.             env.confCore.performUpdateOperation(env.userLogin, false, policy);

  3541.             context.getLogger().info("Invocazione completata con successo");
  3542.         }
  3543.         catch(javax.ws.rs.WebApplicationException e) {
  3544.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3545.             throw e;
  3546.         }
  3547.         catch(Throwable e) {
  3548.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3549.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3550.         }
  3551.     }
  3552.     
  3553.     /**
  3554.      * Consente di modificare la configurazione relativa alla registrazione dei diagnostici
  3555.      *
  3556.      * Questa operazione consente di aggiornare la configurazione relativa alla registrazione dei diagnostici
  3557.      *
  3558.      */
  3559.     @Override
  3560.     public void updateErogazioneRegistrazioneDiagnostici(RegistrazioneDiagnosticiConfigurazione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3561.         IContext context = this.getContext();
  3562.         try {
  3563.             context.getLogger().info("Invocazione in corso ...");     

  3565.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3566.             context.getLogger().debug("Autorizzazione completata con successo");     
  3567.                         
  3568.             BaseHelper.throwIfNull(body);
  3569.             
  3570.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3571.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3572.             
  3573.             ErogazioniApiHelper.updateTracciamento(body, pa, env);
  3574.             
  3575.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3576.         
  3577.             context.getLogger().info("Invocazione completata con successo");
  3578.      
  3579.         }
  3580.         catch(javax.ws.rs.WebApplicationException e) {
  3581.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3582.             throw e;
  3583.         }
  3584.         catch(Throwable e) {
  3585.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3586.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3587.         }
  3588.     }

  3590.     /**
  3591.      * Consente di modificare la configurazione relativa alla registrazione dei messaggi
  3592.      *
  3593.      * Questa operazione consente di aggiornare la configurazione relativa alla registrazione dei messaggi
  3594.      *
  3595.      */
  3596.     @Override
  3597.     public void updateErogazioneRegistrazioneMessaggi(RegistrazioneMessaggi body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3598.         IContext context = this.getContext();
  3599.         try {
  3600.             context.getLogger().info("Invocazione in corso ...");     

  3602.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3603.             context.getLogger().debug("Autorizzazione completata con successo");
  3604.             
  3605.             BaseHelper.throwIfNull(body);
  3606.             
  3607.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3608.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3609.             
  3610.             if (body.isRidefinito())
  3611.                 pa.setDump(ErogazioniApiHelper.buildDumpConfigurazione(body, true, env));
  3612.             else
  3613.                 pa.setDump(null);
  3614.             
  3615.             env.paCore.performUpdateOperation(env.userLogin, false, pa);

  3617.             context.getLogger().info("Invocazione completata con successo");
  3618.         
  3619.      
  3620.         }
  3621.         catch(javax.ws.rs.WebApplicationException e) {
  3622.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3623.             throw e;
  3624.         }
  3625.         catch(Throwable e) {
  3626.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3627.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3628.         }
  3629.     }
  3630.     
  3631.     /**
  3632.      * Consente di modificare la configurazione relativa alla registrazione delle transazioni
  3633.      *
  3634.      * Questa operazione consente di aggiornare la configurazione relativa alla registrazione delle transazioni
  3635.      *
  3636.      */
  3637.     @Override
  3638.     public void updateErogazioneRegistrazioneTransazioni(RegistrazioneTransazioniConfigurazione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3639.         IContext context = this.getContext();
  3640.         try {
  3641.             context.getLogger().info("Invocazione in corso ...");     

  3643.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3644.             context.getLogger().debug("Autorizzazione completata con successo");     
  3645.                         
  3646.             BaseHelper.throwIfNull(body);
  3647.             
  3648.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3649.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3650.             
  3651.             ErogazioniApiHelper.updateTracciamento(body, pa, env);
  3652.             
  3653.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3654.         
  3655.             context.getLogger().info("Invocazione completata con successo");
  3656.         
  3657.         }
  3658.         catch(javax.ws.rs.WebApplicationException e) {
  3659.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3660.             throw e;
  3661.         }
  3662.         catch(Throwable e) {
  3663.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3664.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3665.         }
  3666.     }

  3668.     /**
  3669.      * Consente di modificare lo stato del gruppo
  3670.      *
  3671.      * Questa operazione consente di aggiornare lo stato del gruppo
  3672.      *
  3673.      */
  3674.     @Override
  3675.     public void updateErogazioneStato(ApiImplStato body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3676.         IContext context = this.getContext();
  3677.         try {
  3678.             context.getLogger().info("Invocazione in corso ...");     

  3680.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3681.             context.getLogger().debug("Autorizzazione completata con successo");            
  3682.             
  3683.             BaseHelper.throwIfNull(body);   
  3684.             
  3685.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3686.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3687.             
  3688.             IDPortaApplicativa oldIDPortaApplicativaForUpdate = new IDPortaApplicativa();
  3689.             oldIDPortaApplicativaForUpdate.setNome(pa.getNome());
  3690.             pa.setOldIDPortaApplicativaForUpdate(oldIDPortaApplicativaForUpdate);
  3691.             
  3692.             pa.setStato(Helper.boolToStatoFunzionalitaConf(body.isAbilitato()));
  3693.                         
  3694.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3695.             context.getLogger().info("Invocazione completata con successo");
  3696.         }
  3697.         catch(javax.ws.rs.WebApplicationException e) {
  3698.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3699.             throw e;
  3700.         }
  3701.         catch(Throwable e) {
  3702.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3703.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3704.         }
  3705.     }
  3706.     
  3707.     /**
  3708.      * Modifica i dati di una regola di correlazione applicativa per la richiesta
  3709.      *
  3710.      * Questa operazione consente di aggiornare i dati relativi ad una regola di correlazione applicativa per la richiesta
  3711.      *
  3712.      */
  3713.     @Override
  3714.     public void updateErogazioneTracciamentoCorrelazioneApplicativaRichiesta(CorrelazioneApplicativaRichiesta body, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3715.         IContext context = this.getContext();
  3716.         try {
  3717.             context.getLogger().info("Invocazione in corso ...");     

  3719.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3720.             context.getLogger().debug("Autorizzazione completata con successo");
  3721.             
  3722.             BaseHelper.throwIfNull(body);
  3723.             
  3724.             if ( body.getElemento() == null )
  3725.                 body.setElemento("");
  3726.             
  3727.             final String searchElemento = elemento.equals("*")
  3728.                     ? ""
  3729.                     : elemento;
  3730.                         
  3731.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3732.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3733.             final Long idPorta = pa.getId();
  3734.             
  3735.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  3736.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  3737.                     "Accordo Servizio Parte Specifica");
  3738.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3739.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  3740.             
  3741.             if (pa.getCorrelazioneApplicativa() == null)
  3742.                 pa.setCorrelazioneApplicativa(new org.openspcoop2.core.config.CorrelazioneApplicativa());
  3743.             
  3744.             final List<CorrelazioneApplicativaElemento> correlazioni = pa.getCorrelazioneApplicativa().getElementoList();
  3745.             final CorrelazioneApplicativaElemento oldElem = BaseHelper.findAndRemoveFirst(correlazioni, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento));
  3746.             
  3747.             if ( oldElem == null ) 
  3748.                 throw FaultCode.NOT_FOUND.toException("Correlazione Applicativa Richiesta per l'elemento " + elemento + " non trovata ");
  3749.             
  3750.             if ( !correlazioneApplicativaRichiestaCheckData(TipoOperazione.CHANGE, env.requestWrapper, env.pdHelper, false, body, idPorta, oldElem.getId(),
  3751.                     serviceBinding)) {
  3752.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3753.             }
  3754.             
  3755.             correlazioni.add(convert(body));
  3756.                         
  3757.             pa.getCorrelazioneApplicativa().setElementoList(correlazioni);
  3758.             
  3759.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3760.             
  3761.             context.getLogger().info("Invocazione completata con successo");
  3762.          
  3763.         }
  3764.         catch(javax.ws.rs.WebApplicationException e) {
  3765.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3766.             throw e;
  3767.         }
  3768.         catch(Throwable e) {
  3769.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3770.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3771.         }
  3772.     }
  3773.     
  3774.     /**
  3775.      * Modifica i dati di una regola di correlazione applicativa per la risposta
  3776.      *
  3777.      * Questa operazione consente di aggiornare i dati relativi ad una regola di correlazione applicativa per la risposta
  3778.      *
  3779.      */
  3780.     @Override
  3781.     public void updateErogazioneTracciamentoCorrelazioneApplicativaRisposta(CorrelazioneApplicativaRisposta body, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3782.         IContext context = this.getContext();
  3783.         try {
  3784.             context.getLogger().info("Invocazione in corso ...");     

  3786.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3787.             context.getLogger().debug("Autorizzazione completata con successo");     
  3788.             
  3789.             BaseHelper.throwIfNull(body);
  3790.             
  3791.             if ( body.getElemento() == null )
  3792.                 body.setElemento("");
  3793.             
  3794.             final String searchElemento = elemento.equals("*")
  3795.                     ? ""
  3796.                     : elemento;
  3797.                         
  3798.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3799.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3800.             final Long idPorta = pa.getId();
  3801.             
  3802.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  3803.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  3804.                     "Accordo Servizio Parte Specifica");
  3805.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3806.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  3807.             
  3808.             if (pa.getCorrelazioneApplicativaRisposta() == null)
  3809.                 pa.setCorrelazioneApplicativaRisposta(new org.openspcoop2.core.config.CorrelazioneApplicativaRisposta());
  3810.             
  3811.             final List<CorrelazioneApplicativaRispostaElemento> correlazioni = pa.getCorrelazioneApplicativaRisposta().getElementoList();
  3812.             final CorrelazioneApplicativaRispostaElemento oldElem = BaseHelper.findAndRemoveFirst(correlazioni, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento));
  3813.             
  3814.             if ( oldElem == null ) 
  3815.                 throw FaultCode.NOT_FOUND.toException("Correlazione Applicativa Risposta per l'elemento " + elemento + " non trovata ");
  3816.             
  3817.             if ( !correlazioneApplicativaRispostaCheckData(TipoOperazione.CHANGE, env.requestWrapper, env.pdHelper, false, body, idPorta, oldElem.getId(),
  3818.                     serviceBinding)) {
  3819.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3820.             }
  3821.             
  3822.             correlazioni.add(convert(body));
  3823.                         
  3824.             pa.getCorrelazioneApplicativaRisposta().setElementoList(correlazioni);
  3825.             
  3826.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3827.         
  3828.             context.getLogger().info("Invocazione completata con successo");
  3829.         
  3830.      
  3831.         }
  3832.         catch(javax.ws.rs.WebApplicationException e) {
  3833.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3834.             throw e;
  3835.         }
  3836.         catch(Throwable e) {
  3837.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3838.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3839.         }
  3840.     }
  3841.     
  3842.     /**
  3843.      * Consente di modificare la configurazione relativa alla validazione dei contenuti applicativi
  3844.      *
  3845.      * Questa operazione consente di aggiornare la configurazione relativa alla validazione dei contenuti applicativi
  3846.      *
  3847.      */
  3848.     @Override
  3849.     public void updateErogazioneValidazione(Validazione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3850.         IContext context = this.getContext();
  3851.         try {
  3852.             context.getLogger().info("Invocazione in corso ...");     

  3854.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3855.             context.getLogger().debug("Autorizzazione completata con successo");
  3856.             
  3857.             BaseHelper.throwIfNull(body);   
  3858.             
  3859.             final ErogazioniConfEnv env = new ErogazioniConfEnv(context.getServletRequest(), profilo, soggetto, context, nome, versione, gruppo, tipoServizio );
  3860.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(env.idPa);
  3861.             
  3862.             final String stato = BaseHelper.evalnull( () -> body.getStato().toString());
  3863.             final String tipoValidazione = BaseHelper.evalnull( () -> body.getTipo().toString() );
  3864.             
  3865.             env.requestWrapper.overrideParameter(CostantiControlStation.PARAMETRO_PORTE_XSD, stato);
  3866.             if (!env.paHelper.validazioneContenutiCheck(TipoOperazione.OTHER, false)) {
  3867.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  3868.             }
  3869.             
  3870.             final ValidazioneContenutiApplicativi vx = new ValidazioneContenutiApplicativi();
  3871.             // Imposto Mtom al valore eventualmente già presente nel db.
  3872.             vx.setAcceptMtomMessage( BaseHelper.evalnull( () -> pa.getValidazioneContenutiApplicativi().getAcceptMtomMessage()) );
  3873.             vx.setStato( StatoFunzionalitaConWarning.toEnumConstant(stato) );
  3874.             vx.setTipo( ValidazioneContenutiApplicativiTipo.toEnumConstant(tipoValidazione) );
  3875.             
  3876.             pa.setValidazioneContenutiApplicativi(vx);

  3878.             env.paCore.performUpdateOperation(env.userLogin, false, pa);
  3879.         
  3880.             context.getLogger().info("Invocazione completata con successo");
  3881.      
  3882.         }
  3883.         catch(javax.ws.rs.WebApplicationException e) {
  3884.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3885.             throw e;
  3886.         }
  3887.         catch(Throwable e) {
  3888.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3889.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3890.         }
  3891.     }
  3892.     
  3893. }
Created with JaCoCo 0.8.8.202204050719