FruizioniConfigurazioneApiServiceImpl.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.fruizioni.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.PortaDelegata;
  48. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneServiziApplicativi;
  49. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneToken;
  50. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  51. import org.openspcoop2.core.config.Proprieta;
  52. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  53. import org.openspcoop2.core.config.Ruolo;
  54. import org.openspcoop2.core.config.Scope;
  55. import org.openspcoop2.core.config.ServizioApplicativo;
  56. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  57. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  58. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  59. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  60. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  61. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  62. import org.openspcoop2.core.config.constants.ValidazioneContenutiApplicativiTipo;
  63. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  64. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  65. import org.openspcoop2.core.config.rs.server.api.FruizioniConfigurazioneApi;
  66. import org.openspcoop2.core.config.rs.server.api.impl.Enums;
  67. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  68. import org.openspcoop2.core.config.rs.server.api.impl.IdServizio;
  69. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniApiHelper;
  70. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniEnv;
  71. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  72. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneApiKey;
  73. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneApiKeyConfig;
  74. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneApiKeyPosizione;
  75. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneBasic;
  76. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneCustom;
  77. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazioneHttps;
  78. import org.openspcoop2.core.config.rs.server.model.APIImplAutenticazionePrincipal;
  79. import org.openspcoop2.core.config.rs.server.model.ApiCanale;
  80. import org.openspcoop2.core.config.rs.server.model.ApiImplStato;
  81. import org.openspcoop2.core.config.rs.server.model.CachingRisposta;
  82. import org.openspcoop2.core.config.rs.server.model.ConfigurazioneApiCanale;
  83. import org.openspcoop2.core.config.rs.server.model.ConfigurazioneCanaleEnum;
  84. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAttributeAuthority;
  85. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutenticazione;
  86. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutenticazioneToken;
  87. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazione;
  88. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneApplicativi;
  89. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneApplicativo;
  90. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneRuoli;
  91. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneRuolo;
  92. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneScope;
  93. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneScopes;
  94. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiAutorizzazioneView;
  95. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiGestioneToken;
  96. import org.openspcoop2.core.config.rs.server.model.ControlloAccessiIdentificazioneAttributi;
  97. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRichiesta;
  98. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRichiestaEnum;
  99. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRichiestaItem;
  100. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRisposta;
  101. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRispostaEnum;
  102. import org.openspcoop2.core.config.rs.server.model.CorrelazioneApplicativaRispostaItem;
  103. import org.openspcoop2.core.config.rs.server.model.ElencoProprieta;
  104. import org.openspcoop2.core.config.rs.server.model.GestioneCors;
  105. import org.openspcoop2.core.config.rs.server.model.ListaCorrelazioneApplicativaRichiesta;
  106. import org.openspcoop2.core.config.rs.server.model.ListaCorrelazioneApplicativaRisposta;
  107. import org.openspcoop2.core.config.rs.server.model.ListaRateLimitingPolicy;
  108. import org.openspcoop2.core.config.rs.server.model.OneOfControlloAccessiAutenticazioneAutenticazione;
  109. import org.openspcoop2.core.config.rs.server.model.RateLimitingCriteriMetricaEnum;
  110. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyFruizione;
  111. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyFruizioneUpdate;
  112. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyFruizioneView;
  113. import org.openspcoop2.core.config.rs.server.model.RateLimitingPolicyItem;
  114. import org.openspcoop2.core.config.rs.server.model.RegistrazioneMessaggi;
  115. import org.openspcoop2.core.config.rs.server.model.RegistrazioneDiagnosticiConfigurazione;
  116. import org.openspcoop2.core.config.rs.server.model.RegistrazioneTransazioniConfigurazione;
  117. import org.openspcoop2.core.config.rs.server.model.StatoFunzionalitaConWarningEnum;
  118. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazioneEnum;
  119. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazionePrincipalToken;
  120. import org.openspcoop2.core.config.rs.server.model.Validazione;
  121. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  122. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  123. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyRaggruppamento;
  124. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  125. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  126. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  127. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  128. import org.openspcoop2.core.id.IDPortaDelegata;
  129. import org.openspcoop2.core.id.IDServizioApplicativo;
  130. import org.openspcoop2.core.id.IDSoggetto;
  131. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  132. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  133. import org.openspcoop2.core.registry.constants.RuoloContesto;
  134. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  135. import org.openspcoop2.core.registry.constants.ScopeContesto;
  136. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  137. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  138. import org.openspcoop2.message.constants.ServiceBinding;
  139. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneApiKey;
  140. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneBasic;
  141. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazionePrincipal;
  142. import org.openspcoop2.utils.service.BaseImpl;
  143. import org.openspcoop2.utils.service.authorization.AuthorizationConfig;
  144. import org.openspcoop2.utils.service.authorization.AuthorizationManager;
  145. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  146. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  147. import org.openspcoop2.utils.service.beans.utils.ListaUtils;
  148. import org.openspcoop2.utils.service.context.IContext;
  149. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  150. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  151. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  152. import org.openspcoop2.web.ctrlstat.servlet.ApiKeyState;
  153. import org.openspcoop2.web.ctrlstat.servlet.ConsoleUtilities;
  154. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneUtilities;
  155. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  156. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCore;
  157. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  158. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  159. /**
  160.  * FruizioniConfigurazioneApiServiceImpl
  161.  * 
  162.  * @author $Author$
  163.  * @version $Rev$, $Date$
  164.  * 
  165.  */
  166. public class FruizioniConfigurazioneApiServiceImpl extends BaseImpl implements FruizioniConfigurazioneApi {

  168.     public FruizioniConfigurazioneApiServiceImpl(){
  169.         super(org.slf4j.LoggerFactory.getLogger(FruizioniConfigurazioneApiServiceImpl.class));
  170.     }

  172.     private AuthorizationConfig getAuthorizationConfig() throws Exception{
  173.         return new AuthorizationConfig(ServerProperties.getInstance().getProperties());
  174.     }

  176.     /**
  177.      * Aggiunta di applicativi all'elenco degli applicativi autorizzati
  178.      *
  179.      * Questa operazione consente di aggiungere applicativi all'elenco degli applicativi autorizzati
  180.      *
  181.      */
  182.     @Override
  183.     public void addFruizioneControlloAccessiAutorizzazioneApplicativi(ControlloAccessiAutorizzazioneApplicativo body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  184.         IContext context = this.getContext();
  185.         try {
  186.             context.getLogger().info("Invocazione in corso ...");     

  188.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  189.             context.getLogger().debug("Autorizzazione completata con successo");
  190.             
  191.             BaseHelper.throwIfNull(body);
  192.             
  193.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio);        
  194.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  195.             
  196.             final IDServizioApplicativo idSA = new IDServizioApplicativo();
  197.                 idSA.setIdSoggettoProprietario(env.idSoggetto.toIDSoggetto());
  198.                 idSA.setNome(body.getApplicativo());
  199.                 
  200.                 if ( !TipoAutorizzazione.isAuthenticationRequired(pd.getAutorizzazione())) {
  201.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autenticazione puntuale non è abilitata");
  202.                 }
  203.             
  204.             final ServizioApplicativo sa = BaseHelper.supplyOrNonValida( 
  205.                     () -> env.saCore.getServizioApplicativo(idSA),
  206.                     "Servizio Applicativo " + idSA.toString()
  207.                 );
  208.             
  209.             // Prendo la lista di servizi applicativi associati al soggetto
  210.             final org.openspcoop2.core.config.constants.CredenzialeTipo tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.toEnumConstant(pd.getAutenticazione());
  211.             if(tipoAutenticazione==null) {
  212.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non risulta abilitato un tipo di autenticazione trasporto nella fruizione selezionata");
  213.             }
  214.             Boolean appId = null;
  215.             if(org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  216.                 ApiKeyState apiKeyState =  new ApiKeyState(env.pdCore.getParametroAutenticazione(pd.getAutenticazione(), pd.getProprietaAutenticazioneList()));
  217.                 appId = apiKeyState.appIdSelected;
  218.             }
  219.             
  220.             boolean bothSslAndToken = false;
  221.             List<IDServizioApplicativoDB> saCompatibili = env.saCore.soggettiServizioApplicativoList(env.idSoggetto.toIDSoggetto(),env.userLogin,tipoAutenticazione, appId,
  222.                     ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT,
  223.                     bothSslAndToken, pd.getGestioneToken()!=null ? pd.getGestioneToken().getPolicy() : null);
  224.             if (!BaseHelper.findFirst(saCompatibili, s -> s.getId().equals(sa.getId())).isPresent()) {
  225.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il tipo di credenziali dell'Applicativo non sono compatibili con l'autenticazione impostata nella fruizione selezionata");
  226.             }

  228.             if ( BaseHelper.findFirst(
  229.                         pd.getServizioApplicativoList(),
  230.                         s -> s.getNome().equals(sa.getNome())
  231.                         ).isPresent()
  232.                 ) {
  233.                 throw FaultCode.CONFLITTO.toException("Servizio Applicativo già associato");
  234.             }
  235.                     
  236.             env.requestWrapper.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, pd.getId().toString());
  237.             env.requestWrapper.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, env.idSoggetto.getId().toString());
  238.             env.requestWrapper.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_SERVIZIO_APPLICATIVO, sa.getNome());
  239.             
  240.             if (!env.pdHelper.porteDelegateServizioApplicativoCheckData(TipoOperazione.ADD)) {
  241.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  242.             }
  243.             
  244.             
  245.             PortaDelegataServizioApplicativo pdSa = new PortaDelegataServizioApplicativo();
  246.             pdSa.setNome(body.getApplicativo());
  247.             pd.addServizioApplicativo(pdSa);
  248.             
  249.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  250.             
  251.             context.getLogger().info("Invocazione completata con successo");
  252.         
  253.      
  254.             // Bug Fix: altrimenti viene generato 204
  255.             context.getServletResponse().setStatus(201);
  256.         }
  257.         catch(javax.ws.rs.WebApplicationException e) {
  258.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  259.             throw e;
  260.         }
  261.         catch(Throwable e) {
  262.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  263.             throw FaultCode.ERRORE_INTERNO.toException(e);
  264.         }
  265.     }
  266.     
  267.     /**
  268.      * Aggiunta di applicativi all'elenco degli applicativi token autorizzati
  269.      *
  270.      * Questa operazione consente di aggiungere applicativi all'elenco degli applicativi token autorizzati
  271.      *
  272.      */
  273.     @Override
  274.     public void addFruizioneControlloAccessiAutorizzazioneApplicativiToken(ControlloAccessiAutorizzazioneApplicativo body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  275.         IContext context = this.getContext();
  276.         try {
  277.             context.getLogger().info("Invocazione in corso ...");     

  279.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  280.             context.getLogger().debug("Autorizzazione completata con successo");     
  281.                         
  282.             BaseHelper.throwIfNull(body);
  283.             
  284.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio);        
  285.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  286.             
  287.             final IDServizioApplicativo idSA = new IDServizioApplicativo();
  288.             idSA.setIdSoggettoProprietario(env.idSoggetto.toIDSoggetto());
  289.             idSA.setNome(body.getApplicativo());
  290.             
  291.             String tokenPolicy = null;
  292.             if(pd.getGestioneToken()==null || pd.getGestioneToken().getPolicy()==null) {
  293.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione token per richiedente non è utilizzabile, non risulta abilitata una token policy di validazione");
  294.             }
  295.             tokenPolicy = pd.getGestioneToken().getPolicy();
  296.             if(pd.getAutorizzazioneToken()==null || !StatoFunzionalita.ABILITATO.equals(pd.getAutorizzazioneToken().getAutorizzazioneApplicativi())) {
  297.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione token per richiedente non è abilitata");
  298.             }
  299.             
  300.             final ServizioApplicativo sa = BaseHelper.supplyOrNonValida( 
  301.                     () -> env.saCore.getServizioApplicativo(idSA),
  302.                     "Servizio Applicativo " + idSA.toString()
  303.                 );
  304.             
  305.             // Prendo la lista di servizi applicativi associati al soggetto
  306.             final org.openspcoop2.core.config.constants.CredenzialeTipo tipoAutenticazione = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  307.             Boolean appId = null;
  308.             boolean bothSslAndToken = false;
  309.             List<IDServizioApplicativoDB> saCompatibili = env.saCore.soggettiServizioApplicativoList(env.idSoggetto.toIDSoggetto(),env.userLogin,tipoAutenticazione, appId,
  310.                     ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT,
  311.                     bothSslAndToken, tokenPolicy);
  312.             if (!BaseHelper.findFirst(saCompatibili, s -> s.getId().equals(sa.getId())).isPresent()) {
  313.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il tipo di credenziali dell'Applicativo non sono compatibili con l'autenticazione impostata nella fruizione selezionata");
  314.             }

  316.             if(pd.getAutorizzazioneToken()==null) {
  317.                 pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  318.             }
  319.             if(pd.getAutorizzazioneToken().getServiziApplicativi()==null) {
  320.                 pd.getAutorizzazioneToken().setServiziApplicativi(new PortaDelegataAutorizzazioneServiziApplicativi());
  321.             }
  322.             
  323.             if ( BaseHelper.findFirst(
  324.                         pd.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList(),
  325.                         s -> s.getNome().equals(sa.getNome())
  326.                         ).isPresent()
  327.                 ) {
  328.                 throw FaultCode.CONFLITTO.toException("Servizio Applicativo già associato");
  329.             }
  330.                     
  331.             env.requestWrapper.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, pd.getId().toString());
  332.             env.requestWrapper.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, env.idSoggetto.getId().toString());
  333.             env.requestWrapper.overrideParameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_SERVIZIO_APPLICATIVO, sa.getNome());
  334.             
  335.             if (!env.pdHelper.porteDelegateServizioApplicativoCheckData(TipoOperazione.ADD)) {
  336.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  337.             }
  338.             
  339.             
  340.             PortaDelegataServizioApplicativo pdSa = new PortaDelegataServizioApplicativo();
  341.             pdSa.setNome(body.getApplicativo());
  342.             pd.getAutorizzazioneToken().getServiziApplicativi().addServizioApplicativo(pdSa);
  343.             
  344.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  345.             
  346.             context.getLogger().info("Invocazione completata con successo");
  347.         
  348.      
  349.             // Bug Fix: altrimenti viene generato 204
  350.             context.getServletResponse().setStatus(201);
  351.      
  352.         }
  353.         catch(javax.ws.rs.WebApplicationException e) {
  354.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  355.             throw e;
  356.         }
  357.         catch(Throwable e) {
  358.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  359.             throw FaultCode.ERRORE_INTERNO.toException(e);
  360.         }
  361.     }

  363.     /**
  364.      * Aggiunta di ruoli all'elenco dei ruoli autorizzati
  365.      *
  366.      * Questa operazione consente di aggiungere ruoli all'elenco dei ruoli autorizzati
  367.      *
  368.      */
  369.     @Override
  370.     public void addFruizioneControlloAccessiAutorizzazioneRuoli(ControlloAccessiAutorizzazioneRuolo body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  371.         IContext context = this.getContext();
  372.         try {
  373.             context.getLogger().info("Invocazione in corso ...");     

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

  378.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  379.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  380.             
  381.             if ( !TipoAutorizzazione.isRolesRequired(pd.getAutorizzazione())) {
  382.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione per ruoli non è abilitata");
  383.                 
  384.             }
  385.             
  386.             final RuoliCore ruoliCore = new RuoliCore(env.stationCore);
  387.             BaseHelper.supplyOrNonValida( 
  388.                     () -> ruoliCore.getRuolo(body.getRuolo())
  389.                     , "Ruolo " + body.getRuolo()
  390.                 );
  391.             
  392.             if(pd.getRuoli()==null){
  393.                 pd.setRuoli(new AutorizzazioneRuoli());
  394.             }
  395.             
  396.             // ================================
  397.             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  398.             filtroRuoli.setContesto(RuoloContesto.PORTA_DELEGATA);
  399.             filtroRuoli.setTipologia(RuoloTipologia.QUALSIASI);
  400.             if(TipoAutorizzazione.isInternalRolesRequired(pd.getAutorizzazione()) ){
  401.                 filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  402.             }
  403.             else if(TipoAutorizzazione.isExternalRolesRequired(pd.getAutorizzazione()) ){
  404.                 filtroRuoli.setTipologia(RuoloTipologia.ESTERNO);
  405.             }
  406.             
  407.             List<String> ruoliAmmessi = env.stationCore.getAllRuoli(filtroRuoli);
  408.             
  409.             if ( !ruoliAmmessi.contains(body.getRuolo())) {
  410.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo " + body.getRuolo() + "non è tra i ruoli ammissibili per il gruppo"); 
  411.             }
  412.             
  413.             final List<String> ruoliPresenti = pd.getRuoli().getRuoloList().stream().map( r -> r.getNome()).collect(Collectors.toList());
  414.             
  415.             if ( BaseHelper.findFirst( ruoliPresenti, r -> r.equals(body.getRuolo())).isPresent()) {
  416.                 throw FaultCode.CONFLITTO.toException("Il ruolo " + body.getRuolo() + " è già associato al gruppo scelto");
  417.             }
  418.             
  419.             if (!env.paHelper.ruoloCheckData(TipoOperazione.ADD, body.getRuolo(), ruoliPresenti)) {
  420.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  421.             } 
  422.             // ================================ CHECK RUOLI
  423.             
  424.             Ruolo ruolo = new Ruolo();
  425.             ruolo.setNome(body.getRuolo());
  426.             pd.getRuoli().addRuolo(ruolo);

  428.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);

  430.             context.getLogger().info("Invocazione completata con successo");
  431.         
  432.             // Bug Fix: altrimenti viene generato 204
  433.             context.getServletResponse().setStatus(201);
  434.      
  435.         }
  436.         catch(javax.ws.rs.WebApplicationException e) {
  437.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  438.             throw e;
  439.         }
  440.         catch(Throwable e) {
  441.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  442.             throw FaultCode.ERRORE_INTERNO.toException(e);
  443.         }
  444.     }

  446.     /**
  447.      * Aggiunta di ruoli all'elenco dei ruoli token autorizzati
  448.      *
  449.      * Questa operazione consente di aggiungere ruoli all'elenco dei ruoli token autorizzati
  450.      *
  451.      */
  452.     @Override
  453.     public void addFruizioneControlloAccessiAutorizzazioneRuoliToken(ControlloAccessiAutorizzazioneRuolo body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  454.         IContext context = this.getContext();
  455.         try {
  456.             context.getLogger().info("Invocazione in corso ...");     

  458.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  459.             context.getLogger().debug("Autorizzazione completata con successo");     
  460.                         
  461.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  462.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  463.             
  464.             if(pd.getAutorizzazioneToken()==null || !StatoFunzionalita.ABILITATO.equals(pd.getAutorizzazioneToken().getAutorizzazioneRuoli())) {
  465.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione token per ruoli non è abilitata");
  466.             }
  467.             
  468.             final RuoliCore ruoliCore = new RuoliCore(env.stationCore);
  469.             BaseHelper.supplyOrNonValida( 
  470.                     () -> ruoliCore.getRuolo(body.getRuolo())
  471.                     , "Ruolo " + body.getRuolo()
  472.                 );
  473.             
  474.             if(pd.getAutorizzazioneToken()==null) {
  475.                 pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  476.             }
  477.             if(pd.getAutorizzazioneToken().getRuoli()==null) {
  478.                 pd.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  479.             }
  480.             
  481.             // ================================
  482.             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  483.             filtroRuoli.setContesto(RuoloContesto.PORTA_DELEGATA);
  484.             filtroRuoli.setTipologia(RuoloTipologia.QUALSIASI);
  485.             if(TipoAutorizzazione.isInternalRolesRequired(pd.getAutorizzazione()) ){
  486.                 filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  487.             }
  488.             else if(TipoAutorizzazione.isExternalRolesRequired(pd.getAutorizzazione()) ){
  489.                 filtroRuoli.setTipologia(RuoloTipologia.ESTERNO);
  490.             }
  491.             
  492.             List<String> ruoliAmmessi = env.stationCore.getAllRuoli(filtroRuoli);
  493.             
  494.             if ( !ruoliAmmessi.contains(body.getRuolo())) {
  495.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo " + body.getRuolo() + "non è tra i ruoli ammissibili per il gruppo"); 
  496.             }
  497.             
  498.             final List<String> ruoliPresenti = pd.getAutorizzazioneToken().getRuoli().getRuoloList().stream().map( r -> r.getNome()).collect(Collectors.toList());
  499.             
  500.             if ( BaseHelper.findFirst( ruoliPresenti, r -> r.equals(body.getRuolo())).isPresent()) {
  501.                 throw FaultCode.CONFLITTO.toException("Il ruolo " + body.getRuolo() + " è già associato al gruppo scelto");
  502.             }
  503.             
  504.             if (!env.paHelper.ruoloCheckData(TipoOperazione.ADD, body.getRuolo(), ruoliPresenti)) {
  505.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  506.             } 
  507.             // ================================ CHECK RUOLI
  508.             
  509.             Ruolo ruolo = new Ruolo();
  510.             ruolo.setNome(body.getRuolo());
  511.             pd.getAutorizzazioneToken().getRuoli().addRuolo(ruolo);

  513.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);

  515.             context.getLogger().info("Invocazione completata con successo");
  516.         
  517.             // Bug Fix: altrimenti viene generato 204
  518.             context.getServletResponse().setStatus(201);
  519.         }
  520.         catch(javax.ws.rs.WebApplicationException e) {
  521.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  522.             throw e;
  523.         }
  524.         catch(Throwable e) {
  525.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  526.             throw FaultCode.ERRORE_INTERNO.toException(e);
  527.         }
  528.     }
  529.     
  530.    /**
  531.      * Aggiunta di una proprietà di configurazione
  532.      *
  533.      * Questa operazione consente di registrare una proprietà di configurazione
  534.      *
  535.      */
  536.     @Override
  537.     public void addFruizioneProprieta(org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  538.         IContext context = this.getContext();
  539.         try {
  540.             context.getLogger().info("Invocazione in corso ...");     

  542.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  543.             context.getLogger().debug("Autorizzazione completata con successo");     
  544.             
  545.             BaseHelper.throwIfNull(body);   
  546.             
  547.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  548.             if(env.pdCore==null) {
  549.                 throw new CoreException("PdCore not initialized");
  550.             }
  551.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  552.             
  553.             if ((body.getNome().indexOf(" ") != -1) || (body.getValore().indexOf(" ") != -1)) {
  554.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEI_CAMPI_DI_TESTO);
  555.             }
  556.             
  557.             if(pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  558.                 for (Proprieta p : pd.getProprietaList()) {
  559.                     if(p.getNome().equals(body.getNome())) {
  560.                         throw FaultCode.CONFLITTO.toException("Proprietà " + body.getNome() + " già assegnata alla configurazione");
  561.                     }
  562.                 }
  563.             }
  564.             
  565.             Proprieta p = new Proprieta();
  566.             p.setNome(body.getNome());
  567.             if(env.pdCore!=null && env.pdCore.getDriverBYOKUtilities()!=null && 
  568.                     body.isEncrypted()!=null && body.isEncrypted().booleanValue()) {
  569.                 p.setValore(env.pdCore.getDriverBYOKUtilities().wrap(body.getValore()));
  570.             }
  571.             else {
  572.                 if(body.getValore().length()>255) {
  573.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_VALORE_PROPRIETA_255);
  574.                 }
  575.                 p.setValore(body.getValore());
  576.             }
  577.             pd.addProprieta(p);
  578.             
  579.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  580.         
  581.             context.getLogger().info("Invocazione completata con successo");
  582.      
  583.             // Bug Fix: altrimenti viene generato 204
  584.             context.getServletResponse().setStatus(201);
  585.         }
  586.         catch(javax.ws.rs.WebApplicationException e) {
  587.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  588.             throw e;
  589.         }
  590.         catch(Throwable e) {
  591.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  592.             throw FaultCode.ERRORE_INTERNO.toException(e);
  593.         }
  594.     }

  596.     /**
  597.      * Aggiunta di scope all'elenco degli scope autorizzati
  598.      *
  599.      * Questa operazione consente di aggiungere scope all'elenco degli scope autorizzati
  600.      *
  601.      */
  602.     @Override
  603.     public void addFruizioneControlloAccessiAutorizzazioneScope(ControlloAccessiAutorizzazioneScope body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  604.         IContext context = this.getContext();
  605.         try {
  606.             context.getLogger().info("Invocazione in corso ...");     

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

  611.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  612.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  613.             
  614.             if(pd.getScope()==null) {
  615.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'autorizzazione per scope non è abilitata");
  616.             }
  617.             
  618.             // ==================
  619.             FiltroRicercaScope filtroScope = new FiltroRicercaScope();
  620.             filtroScope.setContesto(ScopeContesto.PORTA_APPLICATIVA);
  621.             filtroScope.setTipologia("");
  622.             
  623.             final List<String> scopeAmmessi = env.stationCore.getAllScope(filtroScope);
  624.             final List<String> scopePresenti = pd.getScope().getScopeList().stream().map(Scope::getNome).collect(Collectors.toList());
  625.             
  626.             if ( !scopeAmmessi.contains(body.getScope())) {
  627.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Scope " + body.getScope() + " non presente fra gli scope ammissibili."); 
  628.             }
  629.             
  630.             if ( scopePresenti.contains(body.getScope()) ) {
  631.                 throw FaultCode.CONFLITTO.toException("Scope " + body.getScope() + " già assegnato al gruppo");
  632.             }
  633.             
  634.             if (!env.paHelper.scopeCheckData(TipoOperazione.ADD, body.getScope(), scopePresenti )) {
  635.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  636.                 
  637.             }
  638.             // ================= CHECK SCOPE
  639.             
  640.             Scope scope = new Scope();
  641.             scope.setNome(body.getScope());
  642.             pd.getScope().addScope(scope);
  643.             
  644.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  645.         
  646.             context.getLogger().info("Invocazione completata con successo");
  647.      
  648.             // Bug Fix: altrimenti viene generato 204
  649.             context.getServletResponse().setStatus(201);
  650.             
  651.         }
  652.         catch(javax.ws.rs.WebApplicationException e) {
  653.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  654.             throw e;
  655.         }
  656.         catch(Throwable e) {
  657.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  658.             throw FaultCode.ERRORE_INTERNO.toException(e);
  659.         }
  660.     }
  661.     
  662.     /**
  663.      * Aggiunta di una policy di rate limiting
  664.      *
  665.      * Questa operazione consente di aggiungere una policy di rate limiting
  666.      *
  667.      */
  668.     @Override
  669.     public void addFruizioneRateLimitingPolicy(RateLimitingPolicyFruizione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  670.         IContext context = this.getContext();
  671.         try {
  672.             context.getLogger().info("Invocazione in corso ...");     

  674.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  675.             context.getLogger().debug("Autorizzazione completata con successo");     
  676.                         
  677.             BaseHelper.throwIfNull(body);

  679.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  680.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);

  682.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  683.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  684.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  685.                     "Fruizione");
  686.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  687.             
  688.             final RuoloPolicy ruoloPorta = RuoloPolicy.DELEGATA;
  689.             final String nomePorta = pd.getNome();
  690.                         
  691.             AttivazionePolicy policy = new AttivazionePolicy();
  692.             policy.setFiltro(new AttivazionePolicyFiltro());
  693.             policy.setGroupBy(new AttivazionePolicyRaggruppamento());
  694.             
  695.             String modalita = ErogazioniApiHelper.getDataElementModalita(body.getConfigurazione().getIdentificazione());
  696.             
  697.             String idPolicy = ErogazioniApiHelper.getIdPolicy(body, env.confCore, env.confHelper);
  698.             if(idPolicy==null) {
  699.                 switch (body.getConfigurazione().getIdentificazione()) {
  700.                 case POLICY:
  701.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Policy Utente non trovata");
  702.                 case CRITERI:
  703.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Policy Built-In non trovata che rispettano i criteri forniti");
  704.                 }
  705.             }
  706.             policy.setIdPolicy(idPolicy);
  707.             
  708.             // Questo lo prendo paro paro dal codice della console.
  709.             InfoPolicy infoPolicy = env.confCore.getInfoPolicy(policy.getIdPolicy());
  710.             String serialId = env.confCore.getNextPolicyInstanceSerialId(infoPolicy.getIdPolicy());
  711.             policy.setIdActivePolicy(ControlloTrafficoDriverUtils.buildIdActivePolicy(infoPolicy.getIdPolicy(), serialId));
  712.     
  713.             ErogazioniApiHelper.override(infoPolicy.getTipoRisorsa(), body, env.protocolFactory.getProtocol(),  env.idSoggetto.toIDSoggetto(), env.requestWrapper);
  714.             // Dati Attivazione
  715.             String errorAttivazione = env.confHelper.readDatiAttivazionePolicyFromHttpParameters(policy, false, TipoOperazione.ADD, infoPolicy);
  716.             if ( !StringUtils.isEmpty(errorAttivazione) ) {
  717.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(errorAttivazione));
  718.             }
  719.             
  720.             policy.getFiltro().setEnabled(true);
  721.             policy.getFiltro().setProtocollo(env.tipo_protocollo);
  722.             policy.getFiltro().setRuoloPorta(ruoloPorta);
  723.             policy.getFiltro().setNomePorta(nomePorta);

  725.             policy.getFiltro().setTipoFruitore(pd.getTipoSoggettoProprietario());
  726.             policy.getFiltro().setNomeFruitore(pd.getNomeSoggettoProprietario());

  728.             StringBuilder existsMessage = new StringBuilder();
  729.             if ( ConfigurazioneUtilities.alreadyExists(
  730.                     TipoOperazione.ADD,
  731.                     env.confCore,
  732.                     env.confHelper,
  733.                     policy, 
  734.                     infoPolicy,
  735.                     ruoloPorta, 
  736.                     nomePorta, 
  737.                     env.apcCore.toMessageServiceBinding(apc.getServiceBinding()),
  738.                     existsMessage, 
  739.                     org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE,
  740.                     modalita
  741.                 )) {
  742.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(existsMessage.toString()));
  743.             }
  744.             // Qui viene sollevata eccezione se il check non viene superato
  745.             FruizioniConfigurazioneHelper.attivazionePolicyCheckData(TipoOperazione.ADD, pd, policy,infoPolicy, env, env.apcCore.toMessageServiceBinding(apc.getServiceBinding()), modalita);
  746.             
  747.             // aggiorno prossima posizione nella policy
  748.             ConfigurazioneUtilities.updatePosizioneAttivazionePolicy(env.confCore, infoPolicy, policy, ruoloPorta, nomePorta);
  749.             
  750.             env.confCore.performCreateOperation(env.userLogin, false, policy);
  751.             
  752.             context.getLogger().info("Invocazione completata con successo");
  753.             
  754.             // Bug Fix: altrimenti viene generato 204
  755.             context.getServletResponse().setStatus(201);
  756.         }
  757.         catch(javax.ws.rs.WebApplicationException e) {
  758.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  759.             throw e;
  760.         }
  761.         catch(Throwable e) {
  762.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  763.             throw FaultCode.ERRORE_INTERNO.toException(e);
  764.         }
  765.     }
  766.     
  767.     /**
  768.      * Aggiunta di una regola di correlazione applicativa
  769.      *
  770.      * Questa operazione consente di registrare una regola di correlazione applicativa per la richiesta
  771.      *
  772.      */
  773.     @Override
  774.     public void addFruizioneTracciamentoCorrelazioneApplicativaRichiesta(CorrelazioneApplicativaRichiesta body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  775.         IContext context = this.getContext();
  776.         try {
  777.             context.getLogger().info("Invocazione in corso ...");     

  779.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  780.             context.getLogger().debug("Autorizzazione completata con successo");     
  781.             
  782.             BaseHelper.throwIfNull(body);
  783.             
  784.             if ( body.getElemento() == null )
  785.                 body.setElemento("");              
  786.                         
  787.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  788.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  789.             final Long idPorta = pd.getId();
  790.             
  791.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  792.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  793.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  794.                     "Fruizione");
  795.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  796.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  797.             
  798.             StringBuilder existsMessage = new StringBuilder();
  799.             if ( ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRichiesta(env.pdCore, idPorta, body.getElemento(), 0, existsMessage)) {
  800.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(existsMessage.toString()));
  801.             }

  803.             
  804.             if ( !correlazioneApplicativaRichiestaCheckData(TipoOperazione.ADD, env.requestWrapper, env.paHelper, true, body, idPorta, null,
  805.                     serviceBinding) ) {
  806.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  807.             }
  808.                                     
  809.             CorrelazioneApplicativa ca = pd.getCorrelazioneApplicativa();
  810.             if (ca == null) {
  811.                 ca = new CorrelazioneApplicativa();
  812.             }
  813.             ca.addElemento(convert(body));
  814.             pd.setCorrelazioneApplicativa(ca);
  815.             
  816.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  817.         
  818.             context.getLogger().info("Invocazione completata con successo");
  819.         
  820.             // Bug Fix: altrimenti viene generato 204
  821.             context.getServletResponse().setStatus(201);
  822.         }
  823.         catch(javax.ws.rs.WebApplicationException e) {
  824.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  825.             throw e;
  826.         }
  827.         catch(Throwable e) {
  828.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  829.             throw FaultCode.ERRORE_INTERNO.toException(e);
  830.         }
  831.     }
  832.     
  833.     /**
  834.      * Aggiunta di una regola di correlazione applicativa
  835.      *
  836.      * Questa operazione consente di registrare una regola di correlazione applicativa per la risposta
  837.      *
  838.      */
  839.     @Override
  840.     public void addFruizioneTracciamentoCorrelazioneApplicativaRisposta(CorrelazioneApplicativaRisposta body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  841.         IContext context = this.getContext();
  842.         try {
  843.             context.getLogger().info("Invocazione in corso ...");     

  845.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  846.             context.getLogger().debug("Autorizzazione completata con successo");
  847.             
  848.             BaseHelper.throwIfNull(body);
  849.             
  850.             if ( body.getElemento() == null )
  851.                 body.setElemento("");              
  852.                         
  853.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  854.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  855.             final Long idPorta = pd.getId();
  856.             
  857.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  858.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  859.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  860.                     "Fruizione");
  861.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  862.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  863.             
  864.             StringBuilder existsMessage = new StringBuilder();
  865.             if ( ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRisposta(env.pdCore, idPorta, body.getElemento(), 0, existsMessage)) {
  866.                 throw FaultCode.CONFLITTO.toException(StringEscapeUtils.unescapeHtml(existsMessage.toString()));
  867.             }
  868.             
  869.             if ( !correlazioneApplicativaRispostaCheckData(TipoOperazione.ADD, env.requestWrapper, env.pdHelper, true, body, idPorta, null,
  870.                     serviceBinding)) {
  871.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  872.             }
  873.                                 
  874.             if ( pd.getCorrelazioneApplicativaRisposta() == null)
  875.                 pd.setCorrelazioneApplicativaRisposta(new org.openspcoop2.core.config.CorrelazioneApplicativaRisposta());
  876.             
  877.             pd.getCorrelazioneApplicativaRisposta().addElemento(convert(body));
  878.             
  879.             
  880.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  881.             context.getLogger().info("Invocazione completata con successo");
  882.         
  883.             // Bug Fix: altrimenti viene generato 204
  884.             context.getServletResponse().setStatus(201);
  885.         }
  886.         catch(javax.ws.rs.WebApplicationException e) {
  887.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  888.             throw e;
  889.         }
  890.         catch(Throwable e) {
  891.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  892.             throw FaultCode.ERRORE_INTERNO.toException(e);
  893.         }
  894.     }
  895.     
  896.     /**
  897.      * Elimina applicativi dall'elenco degli applicativi autorizzati
  898.      *
  899.      * Questa operazione consente di eliminare applicativi dall'elenco degli applicativi autorizzati
  900.      *
  901.      */
  902.     @Override
  903.     public void deleteFruizioneControlloAccessiAutorizzazioneApplicativi(String erogatore, String nome, Integer versione, String applicativoAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  904.         IContext context = this.getContext();
  905.         try {
  906.             context.getLogger().info("Invocazione in corso ...");     

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

  911.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  912.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  913.             
  914.             PortaDelegataServizioApplicativo to_remove = BaseHelper.findAndRemoveFirst(pd.getServizioApplicativoList(), sa -> sa.getNome().equals(applicativoAutorizzato));
  915.             
  916.             if (env.delete_404 && to_remove == null) {
  917.                 throw FaultCode.NOT_FOUND.toException("Nessun Applicativo " + applicativoAutorizzato + " è associato al gruppo scelto"); 
  918.             } else if ( to_remove != null ) {
  919.             
  920.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  921.             }
  922.             context.getLogger().info("Invocazione completata con successo");
  923.         
  924.      
  925.         }
  926.         catch(javax.ws.rs.WebApplicationException e) {
  927.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  928.             throw e;
  929.         }
  930.         catch(Throwable e) {
  931.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  932.             throw FaultCode.ERRORE_INTERNO.toException(e);
  933.         }
  934.     }
  935.     
  936.    /**
  937.      * Elimina applicativi dall'elenco degli applicativi token autorizzati
  938.      *
  939.      * Questa operazione consente di eliminare applicativi dall'elenco degli applicativi token autorizzati
  940.      *
  941.      */
  942.     @Override
  943.     public void deleteFruizioneControlloAccessiAutorizzazioneApplicativiToken(String erogatore, String nome, Integer versione, String applicativoAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  944.         IContext context = this.getContext();
  945.         try {
  946.             context.getLogger().info("Invocazione in corso ...");     

  948.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  949.             context.getLogger().debug("Autorizzazione completata con successo");     
  950.                         
  951.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  952.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  953.             
  954.             if(pd.getAutorizzazioneToken()==null) {
  955.                 pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  956.             }
  957.             if(pd.getAutorizzazioneToken().getServiziApplicativi()==null) {
  958.                 pd.getAutorizzazioneToken().setServiziApplicativi(new PortaDelegataAutorizzazioneServiziApplicativi());
  959.             }
  960.             
  961.             PortaDelegataServizioApplicativo to_remove = BaseHelper.findAndRemoveFirst(pd.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList(), sa -> sa.getNome().equals(applicativoAutorizzato));
  962.             
  963.             if (env.delete_404 && to_remove == null) {
  964.                 throw FaultCode.NOT_FOUND.toException("Nessun Applicativo " + applicativoAutorizzato + " è associato al gruppo scelto"); 
  965.             } else if ( to_remove != null ) {
  966.             
  967.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  968.             }
  969.             context.getLogger().info("Invocazione completata con successo");
  970.      
  971.         }
  972.         catch(javax.ws.rs.WebApplicationException e) {
  973.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  974.             throw e;
  975.         }
  976.         catch(Throwable e) {
  977.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  978.             throw FaultCode.ERRORE_INTERNO.toException(e);
  979.         }
  980.     }

  982.     /**
  983.      * Elimina ruoli dall'elenco dei ruoli autorizzati
  984.      *
  985.      * Questa operazione consente di eliminare ruoli dall'elenco dei ruoli autorizzati
  986.      *
  987.      */
  988.     @Override
  989.     public void deleteFruizioneControlloAccessiAutorizzazioneRuoli(String erogatore, String nome, Integer versione, String ruoloAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  990.         IContext context = this.getContext();
  991.         try {
  992.             context.getLogger().info("Invocazione in corso ...");     

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

  997.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  998.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  999.             
  1000.             if (pd.getRuoli() == null)  pd.setRuoli(new AutorizzazioneRuoli());
  1001.             
  1002.             Ruolo to_remove = BaseHelper.findAndRemoveFirst(pd.getRuoli().getRuoloList(), r -> r.getNome().equals(ruoloAutorizzato));
  1003.             
  1004.             if (env.delete_404 && to_remove == null) {
  1005.                 throw FaultCode.NOT_FOUND.toException("Nessun Ruolo " + ruoloAutorizzato + " è associato al gruppo scelto"); 
  1006.             } else if ( to_remove != null ) {
  1007.             
  1008.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  1009.             }
  1010.             
  1011.             context.getLogger().info("Invocazione completata con successo");     
  1012.         }
  1013.         catch(javax.ws.rs.WebApplicationException e) {
  1014.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1015.             throw e;
  1016.         }
  1017.         catch(Throwable e) {
  1018.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1019.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1020.         }
  1021.     }
  1022.     
  1023.     /**
  1024.      * Elimina ruoli dall'elenco dei ruoli token autorizzati
  1025.      *
  1026.      * Questa operazione consente di eliminare ruoli dall'elenco dei ruoli token autorizzati
  1027.      *
  1028.      */
  1029.     @Override
  1030.     public void deleteFruizioneControlloAccessiAutorizzazioneRuoliToken(String erogatore, String nome, Integer versione, String ruoloAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1031.         IContext context = this.getContext();
  1032.         try {
  1033.             context.getLogger().info("Invocazione in corso ...");     

  1035.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1036.             context.getLogger().debug("Autorizzazione completata con successo");     
  1037.                         
  1038.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1039.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1040.             
  1041.             if(pd.getAutorizzazioneToken()==null) {
  1042.                 pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  1043.             }
  1044.             if(pd.getAutorizzazioneToken().getRuoli()==null) {
  1045.                 pd.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  1046.             }
  1047.             
  1048.             Ruolo to_remove = BaseHelper.findAndRemoveFirst(pd.getAutorizzazioneToken().getRuoli().getRuoloList(), r -> r.getNome().equals(ruoloAutorizzato));
  1049.             
  1050.             if (env.delete_404 && to_remove == null) {
  1051.                 throw FaultCode.NOT_FOUND.toException("Nessun Ruolo " + ruoloAutorizzato + " è associato al gruppo scelto"); 
  1052.             } else if ( to_remove != null ) {
  1053.             
  1054.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  1055.             }
  1056.             
  1057.             context.getLogger().info("Invocazione completata con successo");   
  1058.         }
  1059.         catch(javax.ws.rs.WebApplicationException e) {
  1060.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1061.             throw e;
  1062.         }
  1063.         catch(Throwable e) {
  1064.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1065.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1066.         }
  1067.     }

  1069.    /**
  1070.      * Elimina la proprietà di configurazione dall&#x27;elenco di quelle attivate
  1071.      *
  1072.      * Questa operazione consente di eliminare la proprietà di configurazione dall&#x27;elenco di quelle attivate
  1073.      *
  1074.      */
  1075.     @Override
  1076.     public void deleteFruizioneProprietaConfigurazione(String erogatore, String nome, Integer versione, String proprieta, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1077.         IContext context = this.getContext();
  1078.         try {
  1079.             context.getLogger().info("Invocazione in corso ...");     

  1081.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1082.             context.getLogger().debug("Autorizzazione completata con successo");     
  1083.                         
  1084.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1085.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1086.             
  1087.             Proprieta to_remove = null;
  1088.             if(pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  1089.                 to_remove = BaseHelper.findAndRemoveFirst(pd.getProprietaList(), p -> p.getNome().equals(proprieta));
  1090.             }
  1091.             
  1092.             if (env.delete_404 && to_remove == null) {
  1093.                 throw FaultCode.NOT_FOUND.toException("Nessuna proprietà è presente nella configurazione con nome '"+proprieta+"'"); 
  1094.             } else if ( to_remove != null ) {
  1095.             
  1096.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  1097.             }
  1098.         
  1099.             context.getLogger().info("Invocazione completata con successo");        
  1100.         }
  1101.         catch(javax.ws.rs.WebApplicationException e) {
  1102.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1103.             throw e;
  1104.         }
  1105.         catch(Throwable e) {
  1106.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1107.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1108.         }
  1109.     }

  1111.     /**
  1112.      * Elimina scope dall'elenco degli scope autorizzati
  1113.      *
  1114.      * Questa operazione consente di eliminare scope dall'elenco degli scope autorizzati
  1115.      *
  1116.      */
  1117.     @Override
  1118.     public void deleteFruizioneControlloAccessiAutorizzazioneScope(String erogatore, String nome, Integer versione, String scopeAutorizzato, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1119.         IContext context = this.getContext();
  1120.         try {
  1121.             context.getLogger().info("Invocazione in corso ...");     

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

  1126.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1127.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1128.             
  1129.             if (pd.getScope() == null)  pd.setScope(new AutorizzazioneScope());
  1130.             
  1131.             Scope to_remove = BaseHelper.findAndRemoveFirst(pd.getScope().getScopeList(), s -> s.getNome().equals(scopeAutorizzato));
  1132.             
  1133.             if (env.delete_404 && to_remove == null) {
  1134.                 throw FaultCode.NOT_FOUND.toException("Nessuno scope " + scopeAutorizzato + " è associato al gruppo scelto"); 
  1135.             } else if ( to_remove != null ) {
  1136.             
  1137.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  1138.             }
  1139.             
  1140.             context.getLogger().info("Invocazione completata con successo");        
  1141.      
  1142.         }
  1143.         catch(javax.ws.rs.WebApplicationException e) {
  1144.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1145.             throw e;
  1146.         }
  1147.         catch(Throwable e) {
  1148.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1149.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1150.         }
  1151.     }
  1152.     
  1153.     /**
  1154.      * Elimina la policy dall'elenco delle policies attive
  1155.      *
  1156.      * Questa operazione consente di eliminare la policy dall'elenco delle policies attive
  1157.      *
  1158.      */
  1159.     @Override
  1160.     public void deleteFruizioneRateLimitingPolicy(String erogatore, String nome, Integer versione, String idPolicy, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1161.         IContext context = this.getContext();
  1162.         try {
  1163.             context.getLogger().info("Invocazione in corso ...");     

  1165.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1166.             context.getLogger().debug("Autorizzazione completata con successo");     
  1167.                         
  1168.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1169.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1170.             
  1171.             List<AttivazionePolicy> policies = env.confCore.attivazionePolicyList(null, RuoloPolicy.DELEGATA, pd.getNome());
  1172.             AttivazionePolicy policy = BaseHelper.findFirst( policies, p -> (PolicyUtilities.getNomeActivePolicy(p.getAlias(),p.getIdActivePolicy())).equals(idPolicy) ).orElse(null);
  1173.             
  1174.             if ( policy != null ) {
  1175.                 StringBuilder inUsoMessage = new StringBuilder();
  1176.                 List<AttivazionePolicy> policyRimosse = new ArrayList<AttivazionePolicy>();
  1177.                 
  1178.                 ConfigurazioneUtilities.deleteAttivazionePolicy(
  1179.                         new ArrayList<AttivazionePolicy>(Arrays.asList( policy )), 
  1180.                         env.confHelper, 
  1181.                         env.confCore, 
  1182.                         env.userLogin, 
  1183.                         inUsoMessage, 
  1184.                         org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE, policyRimosse
  1185.                     );
  1186.                 
  1187.                 if ( inUsoMessage.length() > 0 ) {
  1188.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(inUsoMessage.toString()));
  1189.                 }
  1190.                 
  1191.             }
  1192.             else if ( env.delete_404 ) {
  1193.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting con id " + idPolicy );
  1194.             }

  1196.             context.getLogger().info("Invocazione completata con successo");
  1197.         }
  1198.         catch(javax.ws.rs.WebApplicationException e) {
  1199.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1200.             throw e;
  1201.         }
  1202.         catch(Throwable e) {
  1203.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1204.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1205.         }
  1206.     }
  1207.     
  1208.     /**
  1209.      * Elimina la regola di correlazione applicativa dall'elenco di quelle attivate per la richiesta
  1210.      *
  1211.      * Questa operazione consente di eliminare la regola di correlazione applicativa dall'elenco di quelle attivate per la richiesta
  1212.      *
  1213.      */
  1214.     @Override
  1215.     public void deleteFruizioneTracciamentoCorrelazioneApplicativaRichiesta(String erogatore, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1216.         IContext context = this.getContext();
  1217.         try {
  1218.             context.getLogger().info("Invocazione in corso ...");     

  1220.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1221.             context.getLogger().debug("Autorizzazione completata con successo");     
  1222.                          
  1223.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1224.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1225.             
  1226.             final CorrelazioneApplicativa correlazioneApplicativa = pd.getCorrelazioneApplicativa();
  1227.             
  1228.             final String searchElemento = elemento.equals("*")
  1229.                     ? ""
  1230.                     : elemento; 
  1231.                                     
  1232.             CorrelazioneApplicativaElemento to_del = BaseHelper.evalnull( () -> BaseHelper.findAndRemoveFirst( 
  1233.                     correlazioneApplicativa.getElementoList(), 
  1234.                     e -> (e.getNome()==null ? "" : e.getNome()).equals(searchElemento)
  1235.                 ));
  1236.             
  1237.             if ( to_del != null ) {
  1238.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  1239.             }
  1240.             
  1241.             else if (env.delete_404) {
  1242.                 throw FaultCode.NOT_FOUND.toException("Correlazione applicativa per l'elemento " + elemento + " non trovata");
  1243.             }
  1244.             
  1245.             
  1246.             context.getLogger().info("Invocazione completata con successo");
  1247.         
  1248.      
  1249.         }
  1250.         catch(javax.ws.rs.WebApplicationException e) {
  1251.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1252.             throw e;
  1253.         }
  1254.         catch(Throwable e) {
  1255.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1256.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1257.         }
  1258.     }
  1259.     
  1260.     /**
  1261.      * Elimina la regola di correlazione applicativa dall'elenco di quelle attivate per la risposta
  1262.      *
  1263.      * Questa operazione consente di eliminare la regola di correlazione applicativa dall'elenco di quelle attivate per la risposta
  1264.      *
  1265.      */
  1266.     @Override
  1267.     public void deleteFruizioneTracciamentoCorrelazioneApplicativaRisposta(String erogatore, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1268.         IContext context = this.getContext();
  1269.         try {
  1270.             context.getLogger().info("Invocazione in corso ...");     

  1272.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1273.             context.getLogger().debug("Autorizzazione completata con successo");     
  1274.                         
  1275.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1276.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1277.             
  1278.             org.openspcoop2.core.config.CorrelazioneApplicativaRisposta correlazioneApplicativa = pd.getCorrelazioneApplicativaRisposta();
  1279.             
  1280.             final String searchElemento = elemento.equals("*")
  1281.                     ? ""
  1282.                     : elemento; 
  1283.                                     
  1284.             CorrelazioneApplicativaRispostaElemento to_del = BaseHelper.evalnull( () -> BaseHelper.findAndRemoveFirst( 
  1285.                     correlazioneApplicativa.getElementoList(), 
  1286.                     e -> (e.getNome()==null ? "" : e.getNome()).equals(searchElemento)
  1287.                 ));
  1288.             
  1289.             if ( to_del != null ) {
  1290.                 env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  1291.             }
  1292.             
  1293.             else if (env.delete_404) {
  1294.                 throw FaultCode.NOT_FOUND.toException("Correlazione applicativa per l'elemento " + elemento + " non trovata");
  1295.             }        
  1296.             context.getLogger().info("Invocazione completata con successo");
  1297.         
  1298.      
  1299.         }
  1300.         catch(javax.ws.rs.WebApplicationException e) {
  1301.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1302.             throw e;
  1303.         }
  1304.         catch(Throwable e) {
  1305.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1306.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1307.         }
  1308.     }
  1309.     
  1310.     /**
  1311.      * Restituisce la policy XACML associata all'autorizzazione
  1312.      *
  1313.      * Questa operazione consente di ottenere la policy XACML associata all'autorizzazione
  1314.      *
  1315.      */
  1316.     @Override
  1317.     public byte[] downloadFruizioneControlloAccessiAutorizzazioneXacmlPolicy(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1318.         IContext context = this.getContext();
  1319.         try {
  1320.             context.getLogger().info("Invocazione in corso ...");     

  1322.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1323.             context.getLogger().debug("Autorizzazione completata con successo");
  1324.             
  1325.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1326.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1327.             
  1328.             if (pd.getXacmlPolicy() == null)
  1329.                 throw FaultCode.NOT_FOUND.toException("Xacml policy non assegnata al gruppo scelto");
  1330.                        
  1331.             context.getLogger().info("Invocazione completata con successo");
  1332.             return pd.getXacmlPolicy().getBytes();
  1333.      
  1334.         }
  1335.         catch(javax.ws.rs.WebApplicationException e) {
  1336.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1337.             throw e;
  1338.         }
  1339.         catch(Throwable e) {
  1340.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1341.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1342.         }
  1343.     }
  1344.     
  1345.     /**
  1346.      * Restituisce l'elenco delle policy di rate limiting configurate
  1347.      *
  1348.      * Questa operazione consente di ottenere l'elenco delle policy di rate limiting configurate
  1349.      *
  1350.      */
  1351.     @Override
  1352.     public ListaRateLimitingPolicy findAllFruizioneRateLimitingPolicies(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio, String q, Integer limit, Integer offset, RateLimitingCriteriMetricaEnum metrica) {
  1353.         IContext context = this.getContext();
  1354.         try {
  1355.             context.getLogger().info("Invocazione in corso ...");     

  1357.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1358.             context.getLogger().debug("Autorizzazione completata con successo");     
  1359.                         
  1360.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1361.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1362.             
  1363.             final int idLista = Liste.CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY;
  1364.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  1365.             if(metrica!=null) {
  1366.                 String risorsa = ErogazioniApiHelper.getDataElementModalitaRisorsa(metrica);
  1367.                 ricerca.addFilter(idLista, Filtri.FILTRO_TIPO_RISORSA_POLICY, risorsa);
  1368.             }
  1369.             List<AttivazionePolicy> policies = env.confCore.attivazionePolicyList(ricerca, RuoloPolicy.DELEGATA, pd.getNome());

  1371.             if ( env.findall_404 && policies.isEmpty() ) {
  1372.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting associata");
  1373.             }
  1374.             
  1375.             ListaRateLimitingPolicy ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1376.                     ricerca.getIndexIniziale(idLista),
  1377.                     ricerca.getPageSize(idLista), 
  1378.                     ricerca.getNumEntries(idLista), ListaRateLimitingPolicy.class);
  1379.             
  1380.             policies.forEach( p -> {
  1381.                 RateLimitingPolicyItem item = new RateLimitingPolicyItem();
  1382.                 item.setNome(PolicyUtilities.getNomeActivePolicy(p.getAlias(), p.getIdActivePolicy()));
  1383.                 ret.addItemsItem(item);
  1384.             });
  1385.             
  1386.             context.getLogger().info("Invocazione completata con successo");
  1387.             return ret;
  1388.    
  1389.         }
  1390.         catch(javax.ws.rs.WebApplicationException e) {
  1391.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1392.             throw e;
  1393.         }
  1394.         catch(Throwable e) {
  1395.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1396.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1397.         }
  1398.     }
  1399.     
  1400.     /**
  1401.      * Restituisce l'elenco delle regole di correlazione applicativa per la richiesta
  1402.      *
  1403.      * Questa operazione consente di ottenere l'elenco delle regole di correlazione applicativa per la richiesta
  1404.      *
  1405.      */
  1406.     @Override
  1407.     public ListaCorrelazioneApplicativaRichiesta findAllFruizioneTracciamentoCorrelazioneApplicativaRichiesta(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio, String q, Integer limit, Integer offset) {
  1408.         IContext context = this.getContext();
  1409.         try {
  1410.             context.getLogger().info("Invocazione in corso ...");     

  1412.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1413.             context.getLogger().debug("Autorizzazione completata con successo");     
  1414.                         
  1415.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1416.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1417.             
  1418.             final int idLista = Liste.PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA;
  1419.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  1420.             
  1421.             List<CorrelazioneApplicativaElemento> lista = env.pdCore.porteDelegateCorrelazioneApplicativaList(pd.getId().intValue(), ricerca);

  1423.             if ( env.findall_404 && lista.isEmpty() ) {
  1424.                 throw FaultCode.NOT_FOUND.toException("Nessuna regola di correlazione applicativa associata");
  1425.             }
  1426.             
  1427.             ListaCorrelazioneApplicativaRichiesta ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1428.                     ricerca.getIndexIniziale(idLista),
  1429.                     ricerca.getPageSize(idLista), 
  1430.                     ricerca.getNumEntries(idLista), ListaCorrelazioneApplicativaRichiesta.class);
  1431.             
  1432.             lista.forEach( c -> {
  1433.                 CorrelazioneApplicativaRichiestaItem item = new CorrelazioneApplicativaRichiestaItem();
  1434.                 item.setElemento( StringUtils.isEmpty(c.getNome()) 
  1435.                         ? "*"
  1436.                         : c.getNome() 
  1437.                     );
  1438.                 
  1439.                 item.setIdentificazioneTipo(CorrelazioneApplicativaRichiestaEnum.valueOf(c.getIdentificazione().name()));
  1440.                 ret.addItemsItem(item);
  1441.             });
  1442.         
  1443.         
  1444.             context.getLogger().info("Invocazione completata con successo");
  1445.             return ret;
  1446.      
  1447.         }
  1448.         catch(javax.ws.rs.WebApplicationException e) {
  1449.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1450.             throw e;
  1451.         }
  1452.         catch(Throwable e) {
  1453.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1454.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1455.         }
  1456.     }
  1457.     
  1458.     /**
  1459.      * Restituisce l'elenco delle regole di correlazione applicativa per la risposta
  1460.      *
  1461.      * Questa operazione consente di ottenere l'elenco delle regole di correlazione applicativa per la risposta
  1462.      *
  1463.      */
  1464.     @Override
  1465.     public ListaCorrelazioneApplicativaRisposta findAllFruizioneTracciamentoCorrelazioneApplicativaRisposta(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio, String q, Integer limit, Integer offset) {
  1466.         IContext context = this.getContext();
  1467.         try {
  1468.             context.getLogger().info("Invocazione in corso ...");     

  1470.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1471.             context.getLogger().debug("Autorizzazione completata con successo");     
  1472.        
  1473.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1474.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1475.             
  1476.             final int idLista = Liste.PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_RISPOSTA;
  1477.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(), env.tipo_protocollo);
  1478.             
  1479.             List<CorrelazioneApplicativaRispostaElemento> lista = env.pdCore.porteDelegateCorrelazioneApplicativaRispostaList(pd.getId().intValue(), ricerca);

  1481.             if ( env.findall_404 && lista.isEmpty() ) {
  1482.                 throw FaultCode.NOT_FOUND.toException("Nessuna regola di correlazione applicativa della risposta associata");
  1483.             }
  1484.             
  1485.             ListaCorrelazioneApplicativaRisposta ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1486.                     ricerca.getIndexIniziale(idLista),
  1487.                     ricerca.getPageSize(idLista), 
  1488.                     ricerca.getNumEntries(idLista), ListaCorrelazioneApplicativaRisposta.class);
  1489.             
  1490.             lista.forEach( c -> {
  1491.                 CorrelazioneApplicativaRispostaItem item = new CorrelazioneApplicativaRispostaItem();
  1492.                 item.setElemento( StringUtils.isEmpty(c.getNome()) 
  1493.                         ? "*"
  1494.                         : c.getNome() 
  1495.                     );          
  1496.                 item.setIdentificazioneTipo(CorrelazioneApplicativaRispostaEnum.valueOf(c.getIdentificazione().name()));
  1497.                 ret.addItemsItem(item);
  1498.             });        
  1499.             
  1500.             context.getLogger().info("Invocazione completata con successo");
  1501.             return ret;
  1502.              
  1503.         }
  1504.         catch(javax.ws.rs.WebApplicationException e) {
  1505.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1506.             throw e;
  1507.         }
  1508.         catch(Throwable e) {
  1509.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1510.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1511.         }
  1512.     }
  1513.     
  1514.     /**
  1515.      * Restituisce la configurazione relativa al caching delle risposte
  1516.      *
  1517.      * Questa operazione consente di ottenere la configurazione relativa al caching delle risposte
  1518.      *
  1519.      */
  1520.     @Override
  1521.     public CachingRisposta getFruizioneCachingRisposta(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1522.         IContext context = this.getContext();
  1523.         try {
  1524.             context.getLogger().info("Invocazione in corso ...");     

  1526.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1527.             context.getLogger().debug("Autorizzazione completata con successo");     
  1528.                        
  1529.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1530.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);

  1532.             CachingRisposta ret = ErogazioniApiHelper.buildCachingRisposta(pd.getResponseCaching());
  1533.             context.getLogger().info("Invocazione completata con successo");
  1534.             return ret;
  1535.      
  1536.         }
  1537.         catch(javax.ws.rs.WebApplicationException e) {
  1538.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1539.             throw e;
  1540.         }
  1541.         catch(Throwable e) {
  1542.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1543.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1544.         }
  1545.     }
  1546.    
  1547.     /**
  1548.      * Restituisce il canale associato alla fruizione
  1549.      *
  1550.      * Questa operazione consente di ottenere il canale associato alla fruizione
  1551.      *
  1552.      */
  1553.     @Override
  1554.     public ApiCanale getFruizioneCanale(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1555.         IContext context = this.getContext();
  1556.         try {
  1557.             context.getLogger().info("Invocazione in corso ...");     

  1559.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1560.             context.getLogger().debug("Autorizzazione completata con successo");     
  1561.                         
  1562.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1563.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  1564.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( 
  1565.                     () -> ErogazioniApiHelper.getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1566.                     "Fruizione"
  1567.                 );
  1568.             
  1569.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  1570.             final IDPortaDelegata idPd =  ErogazioniApiHelper.getIDGruppoPDDefault(env.idSoggetto.toIDSoggetto(), idAsps, env.apsCore);
  1571.             final PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);
  1572.             
  1573.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1574.             ApiCanale canale = ErogazioniApiHelper.toApiCanale(env, pd, apc, true);
  1575.             
  1576.             context.getLogger().info("Invocazione completata con successo");
  1577.             return canale;
  1578.      
  1579.         }
  1580.         catch(javax.ws.rs.WebApplicationException e) {
  1581.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1582.             throw e;
  1583.         }
  1584.         catch(Throwable e) {
  1585.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1586.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1587.         }
  1588.     }
  1589.  
  1590.     /**
  1591.      * Restituisce la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  1592.      *
  1593.      * Questa operazione consente di ottenere la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  1594.      *
  1595.      */
  1596.     @Override
  1597.     public ControlloAccessiAutenticazione getFruizioneControlloAccessiAutenticazione(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1598.         IContext context = this.getContext();
  1599.         try {
  1600.             context.getLogger().info("Invocazione in corso ...");     

  1602.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1603.             context.getLogger().debug("Autorizzazione completata con successo");
  1604.             
  1605.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1606.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1607.         
  1608.             OneOfControlloAccessiAutenticazioneAutenticazione autRet = null;
  1609.             TipoAutenticazioneEnum tipoAutenticazione = null;
  1610.             if ( TipoAutenticazione.toEnumConstant(pd.getAutenticazione()) == null ) {
  1611.                 tipoAutenticazione = TipoAutenticazioneEnum.CUSTOM;
  1612.             }
  1613.             else {      
  1614.                 tipoAutenticazione = Enums.dualizeMap(Enums.tipoAutenticazioneFromRest).get(TipoAutenticazione.toEnumConstant(pd.getAutenticazione())) ;
  1615.             }
  1616.                         
  1617.             ControlloAccessiAutenticazioneToken token = BaseHelper.evalnull( () -> pd.getGestioneToken().getAutenticazione() ) != null
  1618.                     ? ErogazioniApiHelper.fromGestioneTokenAutenticazione(pd.getGestioneToken().getAutenticazione())
  1619.                     : null;
  1620.             
  1621.             switch(tipoAutenticazione) {
  1622.             case HTTP_BASIC: {
  1623.                 APIImplAutenticazioneBasic authnBasic = new APIImplAutenticazioneBasic();
  1624.                 authnBasic.setTipo(tipoAutenticazione);
  1625.                 authnBasic.setOpzionale(Helper.statoFunzionalitaConfToBool( pd.getAutenticazioneOpzionale() ));
  1626.                 autRet = authnBasic;
  1627.                 
  1628.                 Optional<Proprieta> prop = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazioneBasic.CLEAN_HEADER_AUTHORIZATION.equals(p.getNome())).findAny();
  1629.                 if (prop.isPresent() && prop.get().getValore().equals(ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL_TRUE))
  1630.                     authnBasic.setForward(false);
  1631.                 else
  1632.                     authnBasic.setForward(true);
  1633.                 
  1634.                 break;
  1635.             }
  1636.             case HTTPS: {
  1637.                 APIImplAutenticazioneHttps authnHttps = new APIImplAutenticazioneHttps();
  1638.                 authnHttps.setTipo(tipoAutenticazione);
  1639.                 authnHttps.setOpzionale(Helper.statoFunzionalitaConfToBool( pd.getAutenticazioneOpzionale() ));
  1640.                 autRet = authnHttps;
  1641.                 
  1642.                 break;
  1643.             }
  1644.             case PRINCIPAL: {
  1645.             
  1646.                 APIImplAutenticazionePrincipal authnPrincipal = new APIImplAutenticazionePrincipal();
  1647.                 authnPrincipal.setTipo(tipoAutenticazione);
  1648.                 authnPrincipal.setOpzionale(Helper.statoFunzionalitaConfToBool( pd.getAutenticazioneOpzionale() ));
  1649.                 autRet = authnPrincipal;
  1650.                 
  1651.                 TipoAutenticazionePrincipal tipoAuthnPrincipal = pd.getProprietaAutenticazioneList()
  1652.                         .stream()
  1653.                         .filter( p -> ParametriAutenticazionePrincipal.TIPO_AUTENTICAZIONE.equals(p.getNome()))
  1654.                         .map( p -> TipoAutenticazionePrincipal.toEnumConstant(p.getValore()) )
  1655.                         .findAny()
  1656.                         .orElse(TipoAutenticazionePrincipal.CONTAINER);
  1657.                 authnPrincipal.setTipoPrincipal(Enums.dualizeMap(Enums.tipoAutenticazionePrincipalFromRest).get(tipoAuthnPrincipal));
  1658.                 
  1659.                 switch (authnPrincipal.getTipoPrincipal()) {
  1660.                 case CONTAINER:
  1661.                 case IP_ADDRESS:
  1662.                 case IP_ADDRESS_FORWARDED_FOR:
  1663.                     break;
  1664.                 case HEADER_BASED: {
  1665.                     Optional<Proprieta> prop = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.NOME.equals(p.getNome())).findAny();
  1666.                     if (prop.isPresent()) authnPrincipal.setNome(prop.get().getValore());                   
  1667.                     break;
  1668.                 }
  1669.                 case FORM_BASED: {
  1670.                     Optional<Proprieta> prop = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.NOME.equals(p.getNome())).findAny();
  1671.                     if (prop.isPresent()) authnPrincipal.setNome(prop.get().getValore());                   
  1672.                     break;
  1673.                 }
  1674.                 case URL_BASED: {
  1675.                     Optional<Proprieta> prop = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.PATTERN.equals(p.getNome())).findAny();
  1676.                     if (prop.isPresent()) authnPrincipal.setPattern(prop.get().getValore());
  1677.                     break;
  1678.                 }
  1679.                 case TOKEN: {
  1680.                     Optional<Proprieta> prop = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.TOKEN_CLAIM.equals(p.getNome())).findAny();
  1681.                     if (prop.isPresent()) {
  1682.                         if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_SUBJECT.equals(prop.get().getValore())) {
  1683.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.SUBJECT);
  1684.                         }
  1685.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CLIENT_ID.equals(prop.get().getValore())) {
  1686.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.CLIENTID);
  1687.                         }
  1688.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_USERNAME.equals(prop.get().getValore())) {
  1689.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.USERNAME);
  1690.                         }
  1691.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_EMAIL.equals(prop.get().getValore())) {
  1692.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.EMAIL);
  1693.                         }
  1694.                         else if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CUSTOM.equals(prop.get().getValore())) {
  1695.                             authnPrincipal.setToken(TipoAutenticazionePrincipalToken.CUSTOM);
  1696.                             
  1697.                             Optional<Proprieta> propName = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.NOME.equals(p.getNome())).findAny();
  1698.                             if (propName.isPresent()) authnPrincipal.setNome(propName.get().getValore());
  1699.                         }
  1700.                     }
  1701.                     break;
  1702.                 }
  1703.                 }   // switch config.getTipo
  1704.                 
  1705.                 // IsForward
  1706.                 Optional<Proprieta> prop = pd.getProprietaAutenticazioneList().stream().filter( p -> ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL.equals(p.getNome())).findAny();
  1707.                 if (prop.isPresent() && ParametriAutenticazionePrincipal.CLEAN_PRINCIPAL_TRUE.equals(prop.get().getValore()))
  1708.                     authnPrincipal.setForward(false);
  1709.                 else
  1710.                     authnPrincipal.setForward(true);
  1711.                 
  1712.                 break;
  1713.             }  // case principal
  1714.             
  1715.             case API_KEY: {
  1716.                 
  1717.                 APIImplAutenticazioneApiKey authnApiKey = new APIImplAutenticazioneApiKey();
  1718.                 authnApiKey.setTipo(tipoAutenticazione);
  1719.                 authnApiKey.setOpzionale(Helper.statoFunzionalitaConfToBool( pd.getAutenticazioneOpzionale() ));
  1720.                 autRet = authnApiKey;
  1721.             
  1722.                 if(pd.getProprietaAutenticazioneList()!=null && pd.sizeProprietaAutenticazioneList()>0) {
  1723.                     
  1724.                     APIImplAutenticazioneApiKeyPosizione posizione = null;
  1725.                     APIImplAutenticazioneApiKeyConfig apiKeyNomi = null;
  1726.                     APIImplAutenticazioneApiKeyConfig appIdNomi = null;
  1727.                     boolean useOasNames = false;
  1728.                     
  1729.                     for (Proprieta proprieta : pd.getProprietaAutenticazioneList()) {
  1730.                         String nomeP = proprieta.getNome();
  1731.                         String valoreP = proprieta.getValore();
  1732.                         if(ParametriAutenticazioneApiKey.APP_ID.equals(nomeP)) {
  1733.                             authnApiKey.setAppId(ParametriAutenticazioneApiKey.APP_ID_TRUE.equals(valoreP));
  1734.                         }
  1735.                         else if(ParametriAutenticazioneApiKey.QUERY_PARAMETER.equals(nomeP)) {
  1736.                             if(posizione==null) {
  1737.                                 posizione = new APIImplAutenticazioneApiKeyPosizione();
  1738.                             }
  1739.                             posizione.setQueryParameter(ParametriAutenticazioneApiKey.QUERY_PARAMETER_TRUE.equals(valoreP));
  1740.                         }
  1741.                         else if(ParametriAutenticazioneApiKey.HEADER.equals(nomeP)) {
  1742.                             if(posizione==null) {
  1743.                                 posizione = new APIImplAutenticazioneApiKeyPosizione();
  1744.                             }
  1745.                             posizione.setHeader(ParametriAutenticazioneApiKey.HEADER_TRUE.equals(valoreP));
  1746.                         }
  1747.                         else if(ParametriAutenticazioneApiKey.COOKIE.equals(nomeP)) {
  1748.                             if(posizione==null) {
  1749.                                 posizione = new APIImplAutenticazioneApiKeyPosizione();
  1750.                             }
  1751.                             posizione.setCookie(ParametriAutenticazioneApiKey.COOKIE_TRUE.equals(valoreP));
  1752.                         }
  1753.                         else if(ParametriAutenticazioneApiKey.USE_OAS3_NAMES.equals(nomeP)) {
  1754.                             useOasNames = ParametriAutenticazioneApiKey.USE_OAS3_NAMES_TRUE.equals(valoreP);
  1755.                         }   
  1756.                         else if(ParametriAutenticazioneApiKey.CLEAN_API_KEY.equals(nomeP)) {
  1757.                             boolean clean = ParametriAutenticazioneApiKey.CLEAN_API_KEY_TRUE.equals(valoreP);
  1758.                             authnApiKey.setApiKeyForward(!clean);
  1759.                         }
  1760.                         else if(ParametriAutenticazioneApiKey.CLEAN_APP_ID.equals(nomeP)) {
  1761.                             boolean clean = ParametriAutenticazioneApiKey.CLEAN_APP_ID_TRUE.equals(valoreP);
  1762.                             authnApiKey.setAppIdForward(!clean);
  1763.                         }
  1764.                     }
  1765.                     
  1766.                     if(!useOasNames) {
  1767.                         for (Proprieta proprieta : pd.getProprietaAutenticazioneList()) {
  1768.                             String nomeP = proprieta.getNome();
  1769.                             String valoreP = proprieta.getValore();
  1770.                             if(ParametriAutenticazioneApiKey.NOME_QUERY_PARAMETER_API_KEY.equals(nomeP)) {
  1771.                                 if(apiKeyNomi==null) {
  1772.                                     apiKeyNomi = new APIImplAutenticazioneApiKeyConfig();
  1773.                                 }
  1774.                                 apiKeyNomi.setQueryParameter(valoreP);
  1775.                             }
  1776.                             else if(ParametriAutenticazioneApiKey.NOME_HEADER_API_KEY.equals(nomeP)) {
  1777.                                 if(apiKeyNomi==null) {
  1778.                                     apiKeyNomi = new APIImplAutenticazioneApiKeyConfig();
  1779.                                 }
  1780.                                 apiKeyNomi.setHeader(valoreP);
  1781.                             }
  1782.                             else if(ParametriAutenticazioneApiKey.NOME_COOKIE_API_KEY.equals(nomeP)) {
  1783.                                 if(apiKeyNomi==null) {
  1784.                                     apiKeyNomi = new APIImplAutenticazioneApiKeyConfig();
  1785.                                 }
  1786.                                 apiKeyNomi.setCookie(valoreP);
  1787.                             }
  1788.                             else if(ParametriAutenticazioneApiKey.NOME_QUERY_PARAMETER_APP_ID.equals(nomeP)) {
  1789.                                 if(appIdNomi==null) {
  1790.                                     appIdNomi = new APIImplAutenticazioneApiKeyConfig();
  1791.                                 }
  1792.                                 appIdNomi.setQueryParameter(valoreP);
  1793.                             }
  1794.                             else if(ParametriAutenticazioneApiKey.NOME_HEADER_APP_ID.equals(nomeP)) {
  1795.                                 if(appIdNomi==null) {
  1796.                                     appIdNomi = new APIImplAutenticazioneApiKeyConfig();
  1797.                                 }
  1798.                                 appIdNomi.setHeader(valoreP);
  1799.                             }
  1800.                             else if(ParametriAutenticazioneApiKey.NOME_COOKIE_APP_ID.equals(nomeP)) {
  1801.                                 if(appIdNomi==null) {
  1802.                                     appIdNomi = new APIImplAutenticazioneApiKeyConfig();
  1803.                                 }
  1804.                                 appIdNomi.setCookie(valoreP);
  1805.                             }
  1806.                         }
  1807.                     }
  1808.                     
  1809.                     authnApiKey.setPosizione(posizione);
  1810.                     authnApiKey.setApiKeyNomi(apiKeyNomi);
  1811.                     authnApiKey.setAppIdNomi(appIdNomi);
  1812.                 }
  1813.                 
  1814.                 break;
  1815.             }  // case api-key
  1816.             
  1817.             case CUSTOM: {
  1818.                 APIImplAutenticazioneCustom authnCustom = new APIImplAutenticazioneCustom();
  1819.                 authnCustom.setTipo(tipoAutenticazione);
  1820.                 authnCustom.setOpzionale(Helper.statoFunzionalitaConfToBool( pd.getAutenticazioneOpzionale() ));
  1821.                 autRet = authnCustom;
  1822.                 
  1823.                 authnCustom.setNome(pd.getAutenticazione());
  1824.                 
  1825.                 break;
  1826.             }
  1827.             default:
  1828.                 break;
  1829.             }  // switch autRet.getTipo
  1830.                     
  1831.             ControlloAccessiAutenticazione ret = new ControlloAccessiAutenticazione();
  1832.             ret.setAutenticazione(autRet);
  1833.             ret.setToken(token);
  1834.                                 
  1835.             context.getLogger().info("Invocazione completata con successo");
  1836.             return ret;
  1837.      
  1838.         }
  1839.         catch(javax.ws.rs.WebApplicationException e) {
  1840.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1841.             throw e;
  1842.         }
  1843.         catch(Throwable e) {
  1844.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1845.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1846.         }
  1847.     }
  1848.     
  1849.     /**
  1850.      * Restituisce la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  1851.      *
  1852.      * Questa operazione consente di ottenere la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  1853.      *
  1854.      */
  1855.     @Override
  1856.     public ControlloAccessiAutorizzazioneView getFruizioneControlloAccessiAutorizzazione(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1857.         IContext context = this.getContext();
  1858.         try {
  1859.             context.getLogger().info("Invocazione in corso ...");     

  1861.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1862.             context.getLogger().debug("Autorizzazione completata con successo");     
  1863.                         
  1864.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1865.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1866.             
  1867.             ControlloAccessiAutorizzazioneView ret = ErogazioniApiHelper.controlloAccessiAutorizzazioneFromPD(pd);
  1868.             
  1869.             context.getLogger().info("Invocazione completata con successo");        
  1870.             return ret;
  1871.      
  1872.         }
  1873.         catch(javax.ws.rs.WebApplicationException e) {
  1874.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1875.             throw e;
  1876.         }
  1877.         catch(Throwable e) {
  1878.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1879.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1880.         }
  1881.     }
  1882.     
  1883.     /**
  1884.      * Restituisce l'elenco degli applicativi autorizzati
  1885.      *
  1886.      * Questa operazione consente di ottenere l'elenco degli applicativi autorizzati
  1887.      *
  1888.      */
  1889.     @Override
  1890.     public ControlloAccessiAutorizzazioneApplicativi getFruizioneControlloAccessiAutorizzazioneApplicativi(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1891.         IContext context = this.getContext();
  1892.         try {
  1893.             context.getLogger().info("Invocazione in corso ...");     

  1895.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1896.             context.getLogger().debug("Autorizzazione completata con successo");
  1897.             
  1898.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1899.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1900.             ControlloAccessiAutorizzazioneApplicativi ret = new ControlloAccessiAutorizzazioneApplicativi();
  1901.             
  1902.             int idLista = Liste.PORTE_DELEGATE_SERVIZIO_APPLICATIVO;
  1903.             ConsoleSearch ricerca = Helper.setupRicercaPaginata("", -1, 0, idLista);
  1904.             List<ServizioApplicativo> lista = env.pdCore.porteDelegateServizioApplicativoList(pd.getId(), ricerca);
  1905.             ret.setApplicativi(lista.stream().map( saPA -> saPA.getNome()).collect(Collectors.toList()));
  1906.         
  1907.             context.getLogger().info("Invocazione completata con successo");
  1908.             return ret;
  1909.         }
  1910.         catch(javax.ws.rs.WebApplicationException e) {
  1911.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1912.             throw e;
  1913.         }
  1914.         catch(Throwable e) {
  1915.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1916.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1917.         }
  1918.     }
  1919.     
  1920.     /**
  1921.      * Restituisce l'elenco degli applicativi token autorizzati
  1922.      *
  1923.      * Questa operazione consente di ottenere l'elenco degli applicativi token autorizzati
  1924.      *
  1925.      */
  1926.     @Override
  1927.     public ControlloAccessiAutorizzazioneApplicativi getFruizioneControlloAccessiAutorizzazioneApplicativiToken(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1928.         IContext context = this.getContext();
  1929.         try {
  1930.             context.getLogger().info("Invocazione in corso ...");     

  1932.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1933.             context.getLogger().debug("Autorizzazione completata con successo");     
  1934.                         
  1935.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1936.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1937.             ControlloAccessiAutorizzazioneApplicativi ret = new ControlloAccessiAutorizzazioneApplicativi();
  1938.             
  1939.             int idLista = Liste.PORTE_DELEGATE_TOKEN_SERVIZIO_APPLICATIVO;
  1940.             ConsoleSearch ricerca = Helper.setupRicercaPaginata("", -1, 0, idLista);
  1941.             List<ServizioApplicativo> lista = env.pdCore.porteDelegateServizioApplicativoTokenList(pd.getId(), ricerca);
  1942.             ret.setApplicativi(lista.stream().map( saPA -> saPA.getNome()).collect(Collectors.toList()));
  1943.         
  1944.             context.getLogger().info("Invocazione completata con successo");
  1945.             return ret;
  1946.         }
  1947.         catch(javax.ws.rs.WebApplicationException e) {
  1948.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1949.             throw e;
  1950.         }
  1951.         catch(Throwable e) {
  1952.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1953.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1954.         }
  1955.     }

  1957.     /**
  1958.      * Restituisce l'elenco dei ruoli autorizzati
  1959.      *
  1960.      * Questa operazione consente di ottenere l'elenco dei ruoli autorizzati
  1961.      *
  1962.      */
  1963.     @Override
  1964.     public ControlloAccessiAutorizzazioneRuoli getFruizioneControlloAccessiAutorizzazioneRuoli(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  1965.         IContext context = this.getContext();
  1966.         try {
  1967.             context.getLogger().info("Invocazione in corso ...");     

  1969.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1970.             context.getLogger().debug("Autorizzazione completata con successo");     
  1971.                         
  1972.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  1973.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  1974.             final ControlloAccessiAutorizzazioneRuoli ret = new ControlloAccessiAutorizzazioneRuoli(); 
  1975.             
  1976.             if(pd.getRuoli()!=null && pd.getRuoli().sizeRuoloList()>0) {
  1977.                 ret.setRuoli(BaseHelper.evalnull( () -> pd.getRuoli().getRuoloList().stream().map(Ruolo::getNome).collect(Collectors.toList()) ));
  1978.             }
  1979.         
  1980.             context.getLogger().info("Invocazione completata con successo");
  1981.             return ret;
  1982.           
  1983.         }
  1984.         catch(javax.ws.rs.WebApplicationException e) {
  1985.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1986.             throw e;
  1987.         }
  1988.         catch(Throwable e) {
  1989.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1990.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1991.         }
  1992.     }
  1993.     
  1994.     /**
  1995.      * Restituisce l'elenco dei ruoli token autorizzati
  1996.      *
  1997.      * Questa operazione consente di ottenere l'elenco dei ruoli token autorizzati
  1998.      *
  1999.      */
  2000.     @Override
  2001.     public ControlloAccessiAutorizzazioneRuoli getFruizioneControlloAccessiAutorizzazioneRuoliToken(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2002.         IContext context = this.getContext();
  2003.         try {
  2004.             context.getLogger().info("Invocazione in corso ...");     

  2006.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2007.             context.getLogger().debug("Autorizzazione completata con successo");     
  2008.                         
  2009.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2010.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2011.             final ControlloAccessiAutorizzazioneRuoli ret = new ControlloAccessiAutorizzazioneRuoli(); 
  2012.             
  2013.             if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getRuoli()!=null && pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  2014.                 ret.setRuoli(BaseHelper.evalnull( () -> pd.getAutorizzazioneToken().getRuoli().getRuoloList().stream().map(Ruolo::getNome).collect(Collectors.toList()) ));
  2015.             }
  2016.         
  2017.             context.getLogger().info("Invocazione completata con successo");
  2018.             return ret;
  2019.         }
  2020.         catch(javax.ws.rs.WebApplicationException e) {
  2021.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2022.             throw e;
  2023.         }
  2024.         catch(Throwable e) {
  2025.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2026.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2027.         }
  2028.     }

  2030.     /**
  2031.      * Restituisce l'elenco degli scope autorizzati
  2032.      *
  2033.      * Questa operazione consente di ottenere l'elenco degli scope autorizzati
  2034.      *
  2035.      */
  2036.     @Override
  2037.     public ControlloAccessiAutorizzazioneScopes getFruizioneControlloAccessiAutorizzazioneScope(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2038.         IContext context = this.getContext();
  2039.         try {
  2040.             context.getLogger().info("Invocazione in corso ...");     

  2042.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2043.             context.getLogger().debug("Autorizzazione completata con successo");  
  2044.             
  2045.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2046.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2047.             final ControlloAccessiAutorizzazioneScopes ret = new ControlloAccessiAutorizzazioneScopes();

  2049.             ret.setScope(BaseHelper.evalnull( () -> pd.getScope().getScopeList().stream().map(Scope::getNome).collect(Collectors.toList()) ));
  2050.             
  2051.             context.getLogger().info("Invocazione completata con successo");
  2052.             return ret;
  2053.      
  2054.         }
  2055.         catch(javax.ws.rs.WebApplicationException e) {
  2056.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2057.             throw e;
  2058.         }
  2059.         catch(Throwable e) {
  2060.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2061.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2062.         }
  2063.     }
  2064.     
  2065.    /**
  2066.      * Restituisce le proprietà di configurazione attivate
  2067.      *
  2068.      * Questa operazione consente di ottenere le proprietà di configurazione
  2069.      *
  2070.      */
  2071.     @Override
  2072.     public ElencoProprieta getFruizioneElencoProprieta(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2073.         IContext context = this.getContext();
  2074.         try {
  2075.             context.getLogger().info("Invocazione in corso ...");     

  2077.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2078.             context.getLogger().debug("Autorizzazione completata con successo");     
  2079.                         
  2080.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2081.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2082.         
  2083.             ElencoProprieta ret = new ElencoProprieta();
  2084.             ret.setProprieta(new ArrayList<>());
  2085.             if(pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  2086.                 for (Proprieta p: pd.getProprietaList()) {
  2087.                     org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura retP = new org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura();
  2088.                     retP.setNome(p.getNome());
  2089.                     retP.setValore(p.getValore());
  2090.                     retP.setEncrypted(BYOKUtilities.isWrappedValue(p.getValore()));
  2091.                     ret.addProprietaItem(retP);
  2092.                 }
  2093.             }
  2094.             
  2095.             context.getLogger().info("Invocazione completata con successo");
  2096.             return ret;        
  2097.      
  2098.         }
  2099.         catch(javax.ws.rs.WebApplicationException e) {
  2100.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2101.             throw e;
  2102.         }
  2103.         catch(Throwable e) {
  2104.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2105.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2106.         }
  2107.     }

  2109.     /**
  2110.      * Restituisce la configurazione relativa all'identificazione degli attributi per quanto concerne il controllo degli accessi
  2111.      *
  2112.      * Questa operazione consente di ottenere la configurazione relativa all'identificazione degli attributi
  2113.      *
  2114.      */
  2115.     @Override
  2116.     public ControlloAccessiIdentificazioneAttributi getFruizioneControlloAccessiIdentificazioneAttributi(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2117.         IContext context = this.getContext();
  2118.         try {
  2119.             context.getLogger().info("Invocazione in corso ...");     

  2121.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2122.             context.getLogger().debug("Autorizzazione completata con successo");     
  2123.                         
  2124.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2125.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2126.         
  2127.             final ControlloAccessiIdentificazioneAttributi ret = new ControlloAccessiIdentificazioneAttributi();
  2128.             if(pd.sizeAttributeAuthorityList()>0) {
  2129.                 ret.setAbilitato(true);
  2130.                 ret.setAttributeAuthority(new ArrayList<>());
  2131.                 for (AttributeAuthority aa : pd.getAttributeAuthorityList()) {
  2132.                     ControlloAccessiAttributeAuthority attributeAuthorityItem = new ControlloAccessiAttributeAuthority();
  2133.                     attributeAuthorityItem.setNome(aa.getNome());
  2134.                     if(aa.sizeAttributoList()>0) {
  2135.                         attributeAuthorityItem.setAttributi(new ArrayList<>());
  2136.                         for (String attributeName : aa.getAttributoList()) {
  2137.                             attributeAuthorityItem.addAttributiItem(attributeName);
  2138.                         }
  2139.                     }
  2140.                     ret.addAttributeAuthorityItem(attributeAuthorityItem);
  2141.                 }
  2142.             }
  2143.             else {
  2144.                 ret.setAbilitato(false);
  2145.             }

  2147.             context.getLogger().info("Invocazione completata con successo");
  2148.             return ret;
  2149.         }
  2150.         catch(javax.ws.rs.WebApplicationException e) {
  2151.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2152.             throw e;
  2153.         }
  2154.         catch(Throwable e) {
  2155.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2156.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2157.         }
  2158.     }

  2160.    /**
  2161.      * Restituisce il dettaglio di una proprietà di configurazione
  2162.      *
  2163.      * Questa operazione consente di ottenere il dettaglio di una proprietà di configurazione
  2164.      *
  2165.      */
  2166.     @Override
  2167.     public org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura getFruizioneProprieta(String erogatore, String nome, Integer versione, String proprieta, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2168.         IContext context = this.getContext();
  2169.         try {
  2170.             context.getLogger().info("Invocazione in corso ...");     

  2172.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2173.             context.getLogger().debug("Autorizzazione completata con successo");     
  2174.                         
  2175.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2176.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2177.         
  2178.             Proprieta toGet = null;
  2179.             if(pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  2180.                 Optional<Proprieta> op = BaseHelper.findFirst(pd.getProprietaList(), p -> p.getNome().equals(proprieta));
  2181.                 if(op.isPresent()) {
  2182.                     toGet = op.get();
  2183.                 }
  2184.             }
  2185.             
  2186.             org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura ret = null;
  2187.             if(toGet!=null) {
  2188.                 ret = new org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura();
  2189.                 ret.setNome(toGet.getNome());
  2190.                 ret.setValore(toGet.getValore());
  2191.                 ret.setEncrypted(BYOKUtilities.isWrappedValue(toGet.getValore()));
  2192.             }
  2193.             else {
  2194.                 throw FaultCode.NOT_FOUND.toException("Nessuna proprietà è presente nella configurazione con nome '"+proprieta+"'"); 
  2195.             }
  2196.             
  2197.             context.getLogger().info("Invocazione completata con successo");
  2198.             return ret;
  2199.      
  2200.         }
  2201.         catch(javax.ws.rs.WebApplicationException e) {
  2202.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2203.             throw e;
  2204.         }
  2205.         catch(Throwable e) {
  2206.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2207.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2208.         }
  2209.     }

  2211.     /**
  2212.      * Restituisce la configurazione relativa alla gestione dei token per quanto concerne il controllo degli accessi
  2213.      *
  2214.      * Questa operazione consente di ottenere la configurazione relativa alla gestione dei token
  2215.      *
  2216.      */
  2217.     @Override
  2218.     public ControlloAccessiGestioneToken getFruizioneControlloAccessiGestioneToken(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2219.         IContext context = this.getContext();
  2220.         try {
  2221.             context.getLogger().info("Invocazione in corso ...");     

  2223.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2224.             context.getLogger().debug("Autorizzazione completata con successo");
  2225.                
  2226.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2227.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2228.                         
  2229.             final ControlloAccessiGestioneToken ret = new ControlloAccessiGestioneToken();
  2230.             final GestioneToken paToken = pd.getGestioneToken();
  2231.             
  2232.             ret.setAbilitato(paToken != null);
  2233.             if (paToken != null) {
  2234.                 ret.setIntrospection(StatoFunzionalitaConWarningEnum.fromValue(paToken.getIntrospection().getValue() ));
  2235.                 ret.setPolicy(paToken.getPolicy());
  2236.                 ret.setTokenForward( Helper.statoFunzionalitaConfToBool( paToken.getForward() ));
  2237.                 ret.setTokenOpzionale( Helper.statoFunzionalitaConfToBool(paToken.getTokenOpzionale() ));
  2238.                 ret.setUserInfo(StatoFunzionalitaConWarningEnum.fromValue( paToken.getUserInfo().getValue() ));
  2239.                 ret.setValidazioneJwt(StatoFunzionalitaConWarningEnum.fromValue( paToken.getValidazione().getValue() ));
  2240.             }
  2241.         
  2242.             context.getLogger().info("Invocazione completata con successo");
  2243.             return ret;
  2244.      
  2245.         }
  2246.         catch(javax.ws.rs.WebApplicationException e) {
  2247.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2248.             throw e;
  2249.         }
  2250.         catch(Throwable e) {
  2251.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2252.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2253.         }
  2254.     }
  2255.     
  2256.     /**
  2257.      * Restituisce le informazioni sulla configurazione CORS associata alla fruizione
  2258.      *
  2259.      * Questa operazione consente di ottenere le informazioni sulla configurazione CORS associata alla fruizione identificata dall'erogatore, dal nome e dalla versione
  2260.      *
  2261.      */
  2262.     @Override
  2263.     public GestioneCors getFruizioneGestioneCORS(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  2264.         IContext context = this.getContext();
  2265.         try {
  2266.             context.getLogger().info("Invocazione in corso ...");     

  2268.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2269.             context.getLogger().debug("Autorizzazione completata con successo");     
  2270.                        
  2271.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  2272.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  2273.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( 
  2274.                     () -> ErogazioniApiHelper.getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  2275.                     "Fruizione"
  2276.                 );
  2277.             
  2278.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  2279.             final IDPortaDelegata idPd =  ErogazioniApiHelper.getIDGruppoPDDefault(env.idSoggetto.toIDSoggetto(), idAsps, env.apsCore);
  2280.             final PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);
  2281.             
  2282.             final CorsConfigurazione pdConf = pd.getGestioneCors();        
  2283.             
  2284.             final GestioneCors ret = ErogazioniApiHelper.convert(pdConf);
  2285.             
  2286.             
  2287.             context.getLogger().info("Invocazione completata con successo");
  2288.             return ret;
  2289.      
  2290.         }
  2291.         catch(javax.ws.rs.WebApplicationException e) {
  2292.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2293.             throw e;
  2294.         }
  2295.         catch(Throwable e) {
  2296.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2297.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2298.         }
  2299.     }
  2300.     
  2301.     /**
  2302.      * Restituisce il dettaglio di una policy di rate limiting
  2303.      *
  2304.      * Questa operazione consente di ottenere il dettaglio di una policy di rate limiting
  2305.      *
  2306.      */
  2307.     @Override
  2308.     public RateLimitingPolicyFruizioneView getFruizioneRateLimitingPolicy(String erogatore, String nome, Integer versione, String idPolicy, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2309.         IContext context = this.getContext();
  2310.         try {
  2311.             context.getLogger().info("Invocazione in corso ...");     

  2313.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2314.             context.getLogger().debug("Autorizzazione completata con successo");     
  2315.                         
  2316.             
  2317.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2318.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2319.             
  2320.             AttivazionePolicy policy = BaseHelper.supplyOrNotFound( 
  2321.                     () -> env.confCore.getAttivazionePolicy(idPolicy, RuoloPolicy.DELEGATA, pd.getNome()),
  2322.                     "Rate Limiting Policy con nome " + idPolicy
  2323.                 );
  2324.             if ( policy == null ) 
  2325.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting con nome " + idPolicy );
  2326.             
  2327.             InfoPolicy infoPolicy = env.confCore.getInfoPolicy(policy.getIdPolicy());
  2328.             RateLimitingPolicyFruizioneView ret = ErogazioniApiHelper.convert( policy, infoPolicy, new RateLimitingPolicyFruizioneView() );
  2329.     
  2330.             context.getLogger().info("Invocazione completata con successo");
  2331.             return ret;
  2332.      
  2333.         }
  2334.         catch(javax.ws.rs.WebApplicationException e) {
  2335.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2336.             throw e;
  2337.         }
  2338.         catch(Throwable e) {
  2339.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2340.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2341.         }
  2342.     }

  2344.     /**
  2345.      * Restituisce la configurazione relativa alla registrazione dei diagnostici
  2346.      *
  2347.      * Questa operazione consente di ottenere la configurazione relativa alla registrazione dei diagnostici
  2348.      *
  2349.      */
  2350.     @Override
  2351.     public RegistrazioneDiagnosticiConfigurazione getFruizioneRegistrazioneDiagnostici(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2352.         IContext context = this.getContext();
  2353.         try {
  2354.             context.getLogger().info("Invocazione in corso ...");     

  2356.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2357.             context.getLogger().debug("Autorizzazione completata con successo");     
  2358.                         
  2359.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2360.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2361.             final RegistrazioneDiagnosticiConfigurazione ret = ErogazioniApiHelper.fromDiagnosticiConfigurazione(pd.getTracciamento());
  2362.             
  2363.             context.getLogger().info("Invocazione completata con successo");
  2364.             return ret;
  2365.      
  2366.         }
  2367.         catch(javax.ws.rs.WebApplicationException e) {
  2368.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2369.             throw e;
  2370.         }
  2371.         catch(Throwable e) {
  2372.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2373.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2374.         }
  2375.     }    

  2377.     /**
  2378.      * Restituisce la configurazione relativa alla registrazione dei messaggi
  2379.      *
  2380.      * Questa operazione consente di ottenere la configurazione relativa alla registrazione dei messaggi
  2381.      *
  2382.      */
  2383.     @Override
  2384.     public RegistrazioneMessaggi getFruizioneRegistrazioneMessaggi(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2385.         IContext context = this.getContext();
  2386.         try {
  2387.             context.getLogger().info("Invocazione in corso ...");     

  2389.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2390.             context.getLogger().debug("Autorizzazione completata con successo");     
  2391.                         
  2392.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2393.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2394.             final RegistrazioneMessaggi ret = ErogazioniApiHelper.fromDumpConfigurazione(pd.getDump());
  2395.             
  2396.             context.getLogger().info("Invocazione completata con successo");
  2397.             return ret;     
  2398.         }
  2399.         catch(javax.ws.rs.WebApplicationException e) {
  2400.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2401.             throw e;
  2402.         }
  2403.         catch(Throwable e) {
  2404.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2405.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2406.         }
  2407.     }
  2408.     
  2409.     /**
  2410.      * Restituisce la configurazione relativa alla registrazione delle transazioni
  2411.      *
  2412.      * Questa operazione consente di ottenere la configurazione relativa alla registrazione delle transazioni
  2413.      *
  2414.      */
  2415.     @Override
  2416.     public RegistrazioneTransazioniConfigurazione getFruizioneRegistrazioneTransazioni(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2417.         IContext context = this.getContext();
  2418.         try {
  2419.             context.getLogger().info("Invocazione in corso ...");     

  2421.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2422.             context.getLogger().debug("Autorizzazione completata con successo");     
  2423.             
  2424.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2425.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2426.             final RegistrazioneTransazioniConfigurazione ret = ErogazioniApiHelper.fromTransazioniConfigurazione(pd.getTracciamento(), env);
  2427.         
  2428.             context.getLogger().info("Invocazione completata con successo");
  2429.             return ret;
  2430.      
  2431.         }
  2432.         catch(javax.ws.rs.WebApplicationException e) {
  2433.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2434.             throw e;
  2435.         }
  2436.         catch(Throwable e) {
  2437.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2438.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2439.         }
  2440.     }

  2442.     /**
  2443.      * Restituisce l'indicazione sullo stato del gruppo
  2444.      *
  2445.      * Questa operazione consente di ottenere lo stato attuale del gruppo
  2446.      *
  2447.      */
  2448.     @Override
  2449.     public ApiImplStato getFruizioneStato(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2450.         IContext context = this.getContext();
  2451.         try {
  2452.             context.getLogger().info("Invocazione in corso ...");     

  2454.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2455.             context.getLogger().debug("Autorizzazione completata con successo");     
  2456.                         
  2457.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2458.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2459.             
  2460.             final ApiImplStato ret = new ApiImplStato();
  2461.             ret.setAbilitato(Helper.statoFunzionalitaConfToBool(pd.getStato()));
  2462.                         
  2463.         
  2464.             context.getLogger().info("Invocazione completata con successo");
  2465.             return ret;
  2466.         }
  2467.         catch(javax.ws.rs.WebApplicationException e) {
  2468.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2469.             throw e;
  2470.         }
  2471.         catch(Throwable e) {
  2472.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2473.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2474.         }
  2475.     }
  2476.     
  2477.     /**
  2478.      * Restituisce il dettaglio di una regola di correlazione applicativa per la richiesta
  2479.      *
  2480.      * Questa operazione consente di ottenere il dettaglio di una regola di correlazione applicativa per la richiesta
  2481.      *
  2482.      */
  2483.     @Override
  2484.     public CorrelazioneApplicativaRichiesta getFruizioneTracciamentoCorrelazioneApplicativaRichiesta(String erogatore, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2485.         IContext context = this.getContext();
  2486.         try {
  2487.             context.getLogger().info("Invocazione in corso ...");     

  2489.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2490.             context.getLogger().debug("Autorizzazione completata con successo");
  2491.             
  2492.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2493.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2494.             
  2495.             final String searchElemento = elemento.equals("*")
  2496.                     ? ""
  2497.                     : elemento;         
  2498.             List<CorrelazioneApplicativaElemento> lista = BaseHelper.evalnull( () -> pd.getCorrelazioneApplicativa().getElementoList() );
  2499.             
  2500.             Optional<CorrelazioneApplicativaElemento> el = BaseHelper.findFirst( lista, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento) );
  2501.             
  2502.             if ( !el.isPresent() )
  2503.                 throw FaultCode.NOT_FOUND.toException("CorrelazioneApplicativaRichiesta per l'elemento " + elemento + " non presente");
  2504.             
  2505.             CorrelazioneApplicativaRichiesta ret = ErogazioniApiHelper.convert(el.get());
  2506.             
  2507.             context.getLogger().info("Invocazione completata con successo");
  2508.             return ret;
  2509.      
  2510.         }
  2511.         catch(javax.ws.rs.WebApplicationException e) {
  2512.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2513.             throw e;
  2514.         }
  2515.         catch(Throwable e) {
  2516.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2517.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2518.         }
  2519.     }
  2520.     
  2521.     /**
  2522.      * Restituisce il dettaglio di una regola di correlazione applicativa per la risposta
  2523.      *
  2524.      * Questa operazione consente di ottenere il dettaglio di una regola di correlazione applicativa per la risposta
  2525.      *
  2526.      */
  2527.     @Override
  2528.     public CorrelazioneApplicativaRisposta getFruizioneTracciamentoCorrelazioneApplicativaRisposta(String erogatore, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2529.         IContext context = this.getContext();
  2530.         try {
  2531.             context.getLogger().info("Invocazione in corso ...");     

  2533.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2534.             context.getLogger().debug("Autorizzazione completata con successo");     
  2535.                         
  2536.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2537.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2538.             
  2539.             final String searchElemento = elemento.equals("*")
  2540.                     ? ""
  2541.                     : elemento;         
  2542.             
  2543.             List<CorrelazioneApplicativaRispostaElemento> lista = BaseHelper.evalnull( () -> pd.getCorrelazioneApplicativaRisposta().getElementoList() );
  2544.       
  2545.             Optional<CorrelazioneApplicativaRispostaElemento> el = BaseHelper.findFirst( lista, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento) );
  2546.             
  2547.             if ( !el.isPresent() )
  2548.                 throw FaultCode.NOT_FOUND.toException("CorrelazioneApplicativaRisposta per l'elemento " + elemento + " non presente");
  2549.             
  2550.             CorrelazioneApplicativaRisposta ret = ErogazioniApiHelper.convert(el.get());
  2551.             
  2552.             context.getLogger().info("Invocazione completata con successo");
  2553.             return ret;
  2554.      
  2555.         }
  2556.         catch(javax.ws.rs.WebApplicationException e) {
  2557.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2558.             throw e;
  2559.         }
  2560.         catch(Throwable e) {
  2561.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2562.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2563.         }
  2564.     }
  2565.     
  2566.     /**
  2567.      * Restituisce la configurazione relativa alla validazione dei contenuti applicativi
  2568.      *
  2569.      * Questa operazione consente di ottenere la configurazione relativa alla validazione dei contenuti applicativi
  2570.      *
  2571.      */
  2572.     @Override
  2573.     public Validazione getFruizioneValidazione(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2574.         IContext context = this.getContext();
  2575.         try {
  2576.             context.getLogger().info("Invocazione in corso ...");     

  2578.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2579.             context.getLogger().debug("Autorizzazione completata con successo");     
  2580.             
  2581.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2582.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2583.             final Validazione ret = ErogazioniApiHelper.fromValidazioneContenutiApplicativi(pd.getValidazioneContenutiApplicativi());
  2584.         
  2585.             context.getLogger().info("Invocazione completata con successo");
  2586.             return ret;
  2587.      
  2588.         }
  2589.         catch(javax.ws.rs.WebApplicationException e) {
  2590.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2591.             throw e;
  2592.         }
  2593.         catch(Throwable e) {
  2594.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2595.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2596.         }
  2597.     }

  2599.     /**
  2600.      * Consente di modificare la configurazione relativa al caching delle risposte
  2601.      *
  2602.      * Questa operazione consente di aggiornare la configurazione relativa al caching delle risposte
  2603.      *
  2604.      */
  2605.     @Override
  2606.     public void updateFruizioneCachingRisposta(CachingRisposta body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2607.         IContext context = this.getContext();
  2608.         try {
  2609.             context.getLogger().info("Invocazione in corso ...");     

  2611.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2612.             context.getLogger().debug("Autorizzazione completata con successo");
  2613.             
  2614.             BaseHelper.throwIfNull(body);
  2615.             
  2616.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2617.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2618.             
  2619.             if (!env.paHelper.checkDataConfigurazioneResponseCachingPorta(TipoOperazione.OTHER, true, body.getStato().toString())) {
  2620.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2621.             }
  2622.             
  2623.             ResponseCachingConfigurazione newConfigurazione = ErogazioniApiHelper.buildResponseCachingConfigurazione(body, env.paHelper);
  2624.             
  2625.             pd.setResponseCaching(newConfigurazione);
  2626.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);            
  2627.             

  2629.             context.getLogger().info("Invocazione completata con successo");       
  2630.      
  2631.         }
  2632.         catch(javax.ws.rs.WebApplicationException e) {
  2633.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2634.             throw e;
  2635.         }
  2636.         catch(Throwable e) {
  2637.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2638.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2639.         }
  2640.     }
  2641.     
  2642.     /**
  2643.      * Consente di modificare il canale associato alla fruizione
  2644.      *
  2645.      * Questa operazione consente di aggiornare il canale associato alla fruizione
  2646.      *
  2647.      */
  2648.     @Override
  2649.     public void updateFruizioneCanale(ConfigurazioneApiCanale body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  2650.         IContext context = this.getContext();
  2651.         try {
  2652.             context.getLogger().info("Invocazione in corso ...");     

  2654.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2655.             context.getLogger().debug("Autorizzazione completata con successo");     
  2656.                         
  2657.             BaseHelper.throwIfNull(body);   
  2658.               
  2659.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  2660.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  2661.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( 
  2662.                     () -> ErogazioniApiHelper.getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(),  env),
  2663.                     "Fruizione"
  2664.                 );
  2665.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  2666.             final IDPortaDelegata idPd =  ErogazioniApiHelper.getIDGruppoPDDefault(env.idSoggetto.toIDSoggetto(), idAsps, env.apsCore);
  2667.             final PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);
  2668.             
  2669.             if(ConfigurazioneCanaleEnum.RIDEFINITO.equals(body.getConfigurazione())){
  2670.                 if(body.getCanale()==null || "".equals(body.getCanale())) {
  2671.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un canale");
  2672.                 }
  2673.                 if(!env.canali.contains(body.getCanale())) {
  2674.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il canale fornito '" + body.getCanale() + "' non è presente nel registro");
  2675.                 }
  2676.                 pd.setCanale(body.getCanale());
  2677.             }
  2678.             else {
  2679.                 pd.setCanale(null);
  2680.             }
  2681.             
  2682.             env.paCore.performUpdateOperation(env.userLogin, false, pd);
  2683.             
  2684.             context.getLogger().info("Invocazione completata con successo");
  2685.      
  2686.         }
  2687.         catch(javax.ws.rs.WebApplicationException e) {
  2688.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2689.             throw e;
  2690.         }
  2691.         catch(Throwable e) {
  2692.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2693.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2694.         }
  2695.     }
  2696.     

  2698.     /**
  2699.      * Consente di modificare la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  2700.      *
  2701.      * Questa operazione consente di aggiornare la configurazione relativa all'autenticazione per quanto concerne il controllo degli accessi
  2702.      *
  2703.      */
  2704.     @Override
  2705.     public void updateFruizioneControlloAccessiAutenticazione(ControlloAccessiAutenticazione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2706.         IContext context = this.getContext();
  2707.         try {
  2708.             context.getLogger().info("Invocazione in corso ...");     

  2710.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2711.             context.getLogger().debug("Autorizzazione completata con successo");
  2712.             
  2713.             BaseHelper.throwIfNull(body);
  2714.                         
  2715.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2716.             final PortaDelegata oldPd = env.pdCore.getPortaDelegata(env.idPd);
  2717.             final PortaDelegata newPd = env.pdCore.getPortaDelegata(env.idPd);
  2718.             
  2719.             ErogazioniApiHelper.fillPortaDelegata(env, body, newPd);
  2720.             
  2721.             if (! ErogazioniApiHelper.controlloAccessiCheckPD(env, oldPd, newPd)) {
  2722.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  2723.             }
  2724.         
  2725.             
  2726.             env.pdCore.performUpdateOperation(env.userLogin, false, newPd);
  2727.             
  2728.             context.getLogger().info("Invocazione completata con successo");
  2729.         
  2730.      
  2731.         }
  2732.         catch(javax.ws.rs.WebApplicationException e) {
  2733.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2734.             throw e;
  2735.         }
  2736.         catch(Throwable e) {
  2737.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2738.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2739.         }
  2740.     }
  2741.     
  2742.     /**
  2743.      * Consente di modificare la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  2744.      *
  2745.      * Questa operazione consente di aggiornare la configurazione relativa all'autorizzazione per quanto concerne il controllo degli accessi
  2746.      *
  2747.      */
  2748.     @Override
  2749.     public void updateFruizioneControlloAccessiAutorizzazione(ControlloAccessiAutorizzazione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2750.         IContext context = this.getContext();
  2751.         try {
  2752.             context.getLogger().info("Invocazione in corso ...");     

  2754.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2755.             context.getLogger().debug("Autorizzazione completata con successo");
  2756.             
  2757.             BaseHelper.throwIfNull(body);
  2758.                         
  2759.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2760.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2761.             final PortaDelegata newPd = env.pdCore.getPortaDelegata(env.idPd);
  2762.             
  2763.             ErogazioniApiHelper.fillPortaDelegata(body, newPd);
  2764.             
  2765.             if (!ErogazioniApiHelper.controlloAccessiCheckPD(env, pd, newPd)) {
  2766.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(  env.pd.getMessage() ));
  2767.             }
  2768.             
  2769.             env.pdCore.performUpdateOperation(env.userLogin, false, newPd);
  2770.                         
  2771.             context.getLogger().info("Invocazione completata con successo");        
  2772.      
  2773.         }
  2774.         catch(javax.ws.rs.WebApplicationException e) {
  2775.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2776.             throw e;
  2777.         }
  2778.         catch(Throwable e) {
  2779.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2780.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2781.         }
  2782.     }
  2783.     
  2784.     /**
  2785.      * Consente di modificare la configurazione relativa alla gestione dei token per quanto concerne il controllo degli accessi
  2786.      *
  2787.      * Questa operazione consente di aggiornare la configurazione relativa alla gestione dei token
  2788.      *
  2789.      */
  2790.     @Override
  2791.     public void updateFruizioneControlloAccessiGestioneToken(ControlloAccessiGestioneToken body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2792.         IContext context = this.getContext();
  2793.         try {
  2794.             context.getLogger().info("Invocazione in corso ...");     

  2796.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2797.             context.getLogger().debug("Autorizzazione completata con successo");
  2798.             
  2799.             BaseHelper.throwIfNull(body);

  2801.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2802.             final PortaDelegata newPd = env.pdCore.getPortaDelegata(env.idPd);
  2803.             final PortaDelegata oldPd = env.pdCore.getPortaDelegata(env.idPd);
  2804.             
  2805.             if (body.isAbilitato()) {
  2806.                 GestioneToken gTok = newPd.getGestioneToken() != null ? newPd.getGestioneToken() : new GestioneToken();
  2807.                 ErogazioniApiHelper.fillGestioneToken(gTok, body);
  2808.                 newPd.setGestioneToken(gTok);
  2809.             }
  2810.             else
  2811.                 newPd.setGestioneToken(null);
  2812.             
  2813.             if ( !ErogazioniApiHelper.controlloAccessiCheckPD(env, oldPd, newPd)) {
  2814.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  2815.             }
  2816.             
  2817.             env.pdCore.performUpdateOperation(env.userLogin, false, newPd);
  2818.             context.getLogger().info("Invocazione completata con successo");
  2819.         }
  2820.         catch(javax.ws.rs.WebApplicationException e) {
  2821.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2822.             throw e;
  2823.         }
  2824.         catch(Throwable e) {
  2825.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2826.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2827.         }
  2828.     }
  2829.     
  2830.    /**
  2831.      * Modifica i dati di una proprietà di configurazione
  2832.      *
  2833.      * Questa operazione consente di aggiornare i dati relativi ad una proprietà di configurazione
  2834.      *
  2835.      */
  2836.     @Override
  2837.     public void updateFruizioneProprieta(org.openspcoop2.core.config.rs.server.model.ProprietaOpzioneCifratura body, String erogatore, String nome, Integer versione, String proprieta, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  2838.         IContext context = this.getContext();
  2839.         try {
  2840.             context.getLogger().info("Invocazione in corso ...");     

  2842.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2843.             context.getLogger().debug("Autorizzazione completata con successo");     
  2844.                         
  2845.             BaseHelper.throwIfNull(body);

  2847.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );
  2848.             if(env.pdCore==null) {
  2849.                 throw new CoreException("PdCore not initialized");
  2850.             }
  2851.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  2852.             
  2853.             if ((body.getNome().indexOf(" ") != -1) || (body.getValore().indexOf(" ") != -1)) {
  2854.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEI_CAMPI_DI_TESTO);
  2855.             }
  2856.             
  2857.             if(!proprieta.equals(body.getNome()) &&
  2858.                 // cambio nome proprieta
  2859.                 pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  2860.                 for (Proprieta p : pd.getProprietaList()) {
  2861.                     if(p.getNome().equals(body.getNome())) {
  2862.                         throw FaultCode.CONFLITTO.toException("Proprietà " + body.getNome() + " già assegnata alla configurazione");
  2863.                     }
  2864.                 }
  2865.             }
  2866.             
  2867.             boolean found = false;
  2868.             if(pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  2869.                 for (Proprieta p : pd.getProprietaList()) {
  2870.                     if(p.getNome().equals(proprieta)) {
  2871.                         p.setNome(body.getNome());
  2872.                         if(env.pdCore!=null && env.pdCore.getDriverBYOKUtilities()!=null && 
  2873.                                 body.isEncrypted()!=null && body.isEncrypted().booleanValue()) {
  2874.                             p.setValore(env.pdCore.getDriverBYOKUtilities().wrap(body.getValore()));
  2875.                         }
  2876.                         else {
  2877.                             if(body.getValore().length()>255) {
  2878.                                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_VALORE_PROPRIETA_255);
  2879.                             }
  2880.                             p.setValore(body.getValore());
  2881.                         }
  2882.                         found = true;
  2883.                         break;
  2884.                     }
  2885.                 }
  2886.             }
  2887.             
  2888.             if(!found) {
  2889.                 throw FaultCode.NOT_FOUND.toException("Proprietà " + body.getNome() + " non presente nella configurazione");
  2890.             }
  2891.             
  2892.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  2893.             context.getLogger().info("Invocazione completata con successo");
  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.      * Consente di modificare la configurazione relativa all&#x27;identificazione degli attributi per quanto concerne il controllo degli accessi
  2908.      *
  2909.      * Questa operazione consente di aggiornare la configurazione relativa all&#x27;identificazione degli attributi
  2910.      *
  2911.      */
  2912.     @Override
  2913.     public void updateFruizioneControlloAccessiIdentificazioneAttributi(ControlloAccessiIdentificazioneAttributi body, String erogatore, 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.             BaseHelper.throwIfNull(body);

  2923.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  2924.             final PortaDelegata newPd = env.pdCore.getPortaDelegata(env.idPd);
  2925.             final PortaDelegata oldPd = env.pdCore.getPortaDelegata(env.idPd);
  2926.             
  2927.             if (body.isAbilitato() && body.getAttributeAuthority()!=null && !body.getAttributeAuthority().isEmpty()) {
  2928.                 if(newPd.getAttributeAuthorityList()==null) {
  2929.                     newPd.setAttributeAuthorityList(new ArrayList<AttributeAuthority>());
  2930.                 }
  2931.                 else {
  2932.                     newPd.getAttributeAuthorityList().clear();
  2933.                 }
  2934.                 for (ControlloAccessiAttributeAuthority controlloAccessiAttributeAuthority : body.getAttributeAuthority()) {
  2935.                     
  2936.                     GenericProperties gp = null;
  2937.                     try {
  2938.                         gp = env.confCore.getGenericProperties(controlloAccessiAttributeAuthority.getNome(), org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, false);
  2939.                     }catch(DriverConfigurazioneNotFound notFound) {}
  2940.                     if(gp==null) {
  2941.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException("AttributeAuthority '"+controlloAccessiAttributeAuthority.getNome()+"' non esistente");
  2942.                     }
  2943.                     
  2944.                     AttributeAuthority aa = new AttributeAuthority();
  2945.                     aa.setNome(controlloAccessiAttributeAuthority.getNome());
  2946.                     if(controlloAccessiAttributeAuthority.getAttributi()!=null && !controlloAccessiAttributeAuthority.getAttributi().isEmpty()) {
  2947.                         aa.setAttributoList(controlloAccessiAttributeAuthority.getAttributi());
  2948.                     }
  2949.                     newPd.addAttributeAuthority(aa);
  2950.                 }
  2951.             }
  2952.             else {
  2953.                 if(newPd.getAttributeAuthorityList()!=null) {
  2954.                     newPd.getAttributeAuthorityList().clear();
  2955.                 }
  2956.                 else {
  2957.                     newPd.setAttributeAuthorityList(new ArrayList<AttributeAuthority>());
  2958.                 }
  2959.             }
  2960.             
  2961.             if ( !ErogazioniApiHelper.controlloAccessiCheckPD(env, oldPd, newPd)) {
  2962.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  2963.             }
  2964.             
  2965.             env.pdCore.performUpdateOperation(env.userLogin, false, newPd);
  2966.             context.getLogger().info("Invocazione completata con successo");
  2967.         }
  2968.         catch(javax.ws.rs.WebApplicationException e) {
  2969.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2970.             throw e;
  2971.         }
  2972.         catch(Throwable e) {
  2973.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2974.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2975.         }
  2976.     }
  2977.     

  2979.     /**
  2980.      * Consente di modificare la configurazione CORS associata alla fruizione
  2981.      *
  2982.      * Questa operazione consente di aggiornare la configurazione CORS associata alla fruizione identificata dall'erogatore, dal nome e dalla versione
  2983.      *
  2984.      */
  2985.     @Override
  2986.     public void updateFruizioneGestioneCORS(GestioneCors body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  2987.         IContext context = this.getContext();
  2988.         try {
  2989.             context.getLogger().info("Invocazione in corso ...");     

  2991.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2992.             context.getLogger().debug("Autorizzazione completata con successo");     
  2993.                         
  2994.             BaseHelper.throwIfNull(body);   
  2995.               
  2996.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  2997.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  2998.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound( 
  2999.                     () -> ErogazioniApiHelper.getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(),  env),
  3000.                     "Fruizione"
  3001.                 );
  3002.             final IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());
  3003.             final IDPortaDelegata idPd =  ErogazioniApiHelper.getIDGruppoPDDefault(env.idSoggetto.toIDSoggetto(), idAsps, env.apsCore);
  3004.             final PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);
  3005.             final CorsConfigurazione oldConf = pd.getGestioneCors();
  3006.             
  3007.             if (body.isRidefinito())
  3008.                 pd.setGestioneCors(ErogazioniApiHelper.buildCorsConfigurazione(body, env, oldConf));
  3009.             else
  3010.                 pd.setGestioneCors(null);
  3011.             
  3012.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3013.             
  3014.             context.getLogger().info("Invocazione completata con successo");
  3015.         }
  3016.         catch(javax.ws.rs.WebApplicationException e) {
  3017.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3018.             throw e;
  3019.         }
  3020.         catch(Throwable e) {
  3021.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3022.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3023.         }
  3024.     }
  3025.     
  3026.     /**
  3027.      * Modifica i dati di una policy di rate limiting
  3028.      *
  3029.      * Questa operazione consente di aggiornare i dati relativi ad una policy di rate limiting
  3030.      *
  3031.      */
  3032.     @Override
  3033.     public void updateFruizioneRateLimitingPolicy(RateLimitingPolicyFruizioneUpdate body, String erogatore, String nome, Integer versione, String idPolicy, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3034.         IContext context = this.getContext();
  3035.         try {
  3036.             context.getLogger().info("Invocazione in corso ...");     

  3038.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3039.             context.getLogger().debug("Autorizzazione completata con successo");     
  3040.                         
  3041.             BaseHelper.throwIfNull(body);
  3042.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3043.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  3044.             
  3045.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  3046.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  3047.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  3048.                     "Fruizione");
  3049.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3050.             
  3051.             AttivazionePolicy policy = BaseHelper.supplyOrNotFound( 
  3052.                     () -> env.confCore.getAttivazionePolicy(idPolicy, RuoloPolicy.DELEGATA, pd.getNome()),
  3053.                     "Rate Limiting Policy con nome " + idPolicy
  3054.                 );
  3055.             if ( policy == null ) 
  3056.                 throw FaultCode.NOT_FOUND.toException("Nessuna policy di rate limiting con nome " + idPolicy );
  3057.             
  3058.             InfoPolicy infoPolicy = env.confCore.getInfoPolicy(policy.getIdPolicy());
  3059.             ErogazioniApiHelper.override(infoPolicy.getTipoRisorsa(), body, env.protocolFactory.getProtocol(),  env.idSoggetto.toIDSoggetto(), env.requestWrapper);

  3061.             String errorAttivazione = env.confHelper.readDatiAttivazionePolicyFromHttpParameters(policy, false, TipoOperazione.CHANGE, infoPolicy);
  3062.             if ( !StringUtils.isEmpty(errorAttivazione) ) {
  3063.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(errorAttivazione));
  3064.             }
  3065.             
  3066.             String modalita = ErogazioniApiHelper.getDataElementModalita(infoPolicy.isBuiltIn());
  3067.             FruizioniConfigurazioneHelper.attivazionePolicyCheckData(TipoOperazione.CHANGE, pd, policy,infoPolicy, env, env.apcCore.toMessageServiceBinding(apc.getServiceBinding()), modalita);
  3068.             
  3069.             env.confCore.performUpdateOperation(env.userLogin, false, policy);
  3070.             
  3071.             context.getLogger().info("Invocazione completata con successo");
  3072.         }
  3073.         catch(javax.ws.rs.WebApplicationException e) {
  3074.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3075.             throw e;
  3076.         }
  3077.         catch(Throwable e) {
  3078.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3079.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3080.         }
  3081.     }
  3082.     
  3083.     /**
  3084.      * Consente di modificare la configurazione relativa alla registrazione dei diagnostici
  3085.      *
  3086.      * Questa operazione consente di aggiornare la configurazione relativa alla registrazione dei diagnostici
  3087.      *
  3088.      */
  3089.     @Override
  3090.     public void updateFruizioneRegistrazioneDiagnostici(RegistrazioneDiagnosticiConfigurazione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3091.         IContext context = this.getContext();
  3092.         try {
  3093.             context.getLogger().info("Invocazione in corso ...");     

  3095.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3096.             context.getLogger().debug("Autorizzazione completata con successo");     
  3097.                         
  3098.             BaseHelper.throwIfNull(body);   

  3100.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3101.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  3102.             
  3103.             ErogazioniApiHelper.updateTracciamento(body, pd, env);
  3104.             
  3105.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3106.             
  3107.             context.getLogger().info("Invocazione completata con successo");
  3108.         
  3109.         }
  3110.         catch(javax.ws.rs.WebApplicationException e) {
  3111.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3112.             throw e;
  3113.         }
  3114.         catch(Throwable e) {
  3115.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3116.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3117.         }
  3118.     }

  3120.     /**
  3121.      * Consente di modificare la configurazione relativa alla registrazione dei messaggi
  3122.      *
  3123.      * Questa operazione consente di aggiornare la configurazione relativa alla registrazione dei messaggi
  3124.      *
  3125.      */
  3126.     @Override
  3127.     public void updateFruizioneRegistrazioneMessaggi(RegistrazioneMessaggi body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3128.         IContext context = this.getContext();
  3129.         try {
  3130.             context.getLogger().info("Invocazione in corso ...");     

  3132.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3133.             context.getLogger().debug("Autorizzazione completata con successo");     
  3134.             
  3135.             BaseHelper.throwIfNull(body);   

  3137.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3138.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  3139.             
  3140.             if (body.isRidefinito())
  3141.                 pd.setDump(ErogazioniApiHelper.buildDumpConfigurazione(body, false, env));
  3142.             else
  3143.                 pd.setDump(null);
  3144.             
  3145.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3146.         
  3147.             context.getLogger().info("Invocazione completata con successo");             
  3148.         }
  3149.         catch(javax.ws.rs.WebApplicationException e) {
  3150.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3151.             throw e;
  3152.         }
  3153.         catch(Throwable e) {
  3154.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3155.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3156.         }
  3157.     }
  3158.     
  3159.     /**
  3160.      * Consente di modificare la configurazione relativa alla registrazione delle transazioni
  3161.      *
  3162.      * Questa operazione consente di aggiornare la configurazione relativa alla registrazione delle transazioni
  3163.      *
  3164.      */
  3165.     @Override
  3166.     public void updateFruizioneRegistrazioneTransazioni(RegistrazioneTransazioniConfigurazione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3167.         IContext context = this.getContext();
  3168.         try {
  3169.             context.getLogger().info("Invocazione in corso ...");     

  3171.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3172.             context.getLogger().debug("Autorizzazione completata con successo");     
  3173.                         
  3174.             BaseHelper.throwIfNull(body);   

  3176.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3177.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  3178.             
  3179.             ErogazioniApiHelper.updateTracciamento(body, pd, env);
  3180.             
  3181.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3182.         
  3183.             context.getLogger().info("Invocazione completata con successo");
  3184.         
  3185.         }
  3186.         catch(javax.ws.rs.WebApplicationException e) {
  3187.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3188.             throw e;
  3189.         }
  3190.         catch(Throwable e) {
  3191.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3192.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3193.         }
  3194.     }

  3196.     /**
  3197.      * Consente di modificare lo stato del gruppo
  3198.      *
  3199.      * Questa operazione consente di aggiornare lo stato del gruppo
  3200.      *
  3201.      */
  3202.     @Override
  3203.     public void updateFruizioneStato(ApiImplStato body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3204.         IContext context = this.getContext();
  3205.         try {
  3206.             context.getLogger().info("Invocazione in corso ...");     

  3208.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3209.             context.getLogger().debug("Autorizzazione completata con successo");     
  3210.                            
  3211.             BaseHelper.throwIfNull(body);   

  3213.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3214.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  3215.             
  3216.             IDPortaDelegata oldIDPortaDelegataForUpdate= new IDPortaDelegata();
  3217.             oldIDPortaDelegataForUpdate.setNome(pd.getNome());
  3218.             pd.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
  3219.             
  3220.             pd.setStato(Helper.boolToStatoFunzionalitaConf(body.isAbilitato()));
  3221.                         
  3222.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3223.                 
  3224.             context.getLogger().info("Invocazione completata con successo");
  3225.         
  3226.      
  3227.         }
  3228.         catch(javax.ws.rs.WebApplicationException e) {
  3229.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3230.             throw e;
  3231.         }
  3232.         catch(Throwable e) {
  3233.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3234.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3235.         }
  3236.     }
  3237.     
  3238.     /**
  3239.      * Modifica i dati di una regola di correlazione applicativa per la richiesta
  3240.      *
  3241.      * Questa operazione consente di aggiornare i dati relativi ad una regola di correlazione applicativa per la richiesta
  3242.      *
  3243.      */
  3244.     @Override
  3245.     public void updateFruizioneTracciamentoCorrelazioneApplicativaRichiesta(CorrelazioneApplicativaRichiesta body, String erogatore, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3246.         IContext context = this.getContext();
  3247.         try {
  3248.             context.getLogger().info("Invocazione in corso ...");     

  3250.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3251.             context.getLogger().debug("Autorizzazione completata con successo");     
  3252.                         
  3253.             BaseHelper.throwIfNull(body);

  3255.             if ( body.getElemento() == null )
  3256.                 body.setElemento("");
  3257.             
  3258.             final String searchElemento = elemento.equals("*")
  3259.                     ? ""
  3260.                     : elemento;

  3262.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3263.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);   
  3264.             final Long idPorta = pd.getId();
  3265.             
  3266.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  3267.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  3268.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  3269.                     "Fruizione");
  3270.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3271.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  3272.             
  3273.             if (pd.getCorrelazioneApplicativa() == null)
  3274.                 pd.setCorrelazioneApplicativa(new org.openspcoop2.core.config.CorrelazioneApplicativa());
  3275.             
  3276.             final List<CorrelazioneApplicativaElemento> correlazioni = pd.getCorrelazioneApplicativa().getElementoList();
  3277.             final CorrelazioneApplicativaElemento oldElem = BaseHelper.findAndRemoveFirst(correlazioni, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento));
  3278.             
  3279.             if ( oldElem == null ) 
  3280.                 throw FaultCode.NOT_FOUND.toException("Correlazione Applicativa Richiesta per l'elemento " + elemento + " non trovata ");
  3281.             
  3282.             if ( !correlazioneApplicativaRichiestaCheckData(TipoOperazione.CHANGE, env.requestWrapper, env.pdHelper, true, body, idPorta, oldElem.getId(),
  3283.                     serviceBinding)) {
  3284.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3285.             }
  3286.             
  3287.             correlazioni.add(convert(body));
  3288.                         
  3289.             pd.getCorrelazioneApplicativa().setElementoList(correlazioni);
  3290.             
  3291.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3292.             
  3293.             
  3294.             context.getLogger().info("Invocazione completata con successo");
  3295.         
  3296.      
  3297.         }
  3298.         catch(javax.ws.rs.WebApplicationException e) {
  3299.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3300.             throw e;
  3301.         }
  3302.         catch(Throwable e) {
  3303.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3304.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3305.         }
  3306.     }
  3307.     
  3308.     /**
  3309.      * Modifica i dati di una regola di correlazione applicativa per la risposta
  3310.      *
  3311.      * Questa operazione consente di aggiornare i dati relativi ad una regola di correlazione applicativa per la risposta
  3312.      *
  3313.      */
  3314.     @Override
  3315.     public void updateFruizioneTracciamentoCorrelazioneApplicativaRisposta(CorrelazioneApplicativaRisposta body, String erogatore, String nome, Integer versione, String elemento, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3316.         IContext context = this.getContext();
  3317.         try {
  3318.             context.getLogger().info("Invocazione in corso ...");     

  3320.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3321.             context.getLogger().debug("Autorizzazione completata con successo");     
  3322.                         
  3323.             BaseHelper.throwIfNull(body);

  3325.             if ( body.getElemento() == null )
  3326.                 body.setElemento("");
  3327.             
  3328.             final String searchElemento = elemento.equals("*")
  3329.                     ? ""
  3330.                     : elemento;

  3332.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3333.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);   
  3334.             final Long idPorta = pd.getId();

  3336.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  3337.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  3338.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  3339.                     "Fruizione");
  3340.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3341.             ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  3342.             
  3343.             if (pd.getCorrelazioneApplicativaRisposta() == null)
  3344.                 pd.setCorrelazioneApplicativaRisposta(new org.openspcoop2.core.config.CorrelazioneApplicativaRisposta());
  3345.             
  3346.             final List<CorrelazioneApplicativaRispostaElemento> correlazioni = pd.getCorrelazioneApplicativaRisposta().getElementoList();
  3347.             final CorrelazioneApplicativaRispostaElemento oldElem = BaseHelper.findAndRemoveFirst(correlazioni, c -> (c.getNome()==null ? "" : c.getNome()).equals(searchElemento));
  3348.             
  3349.             if ( oldElem == null ) 
  3350.                 throw FaultCode.NOT_FOUND.toException("Correlazione Applicativa Risposta per l'elemento " + elemento + " non trovata ");
  3351.             
  3352.             if ( !correlazioneApplicativaRispostaCheckData(TipoOperazione.CHANGE, env.requestWrapper, env.pdHelper, true, body, idPorta, oldElem.getId(),
  3353.                     serviceBinding)) {
  3354.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3355.             }
  3356.             
  3357.             correlazioni.add(convert(body));
  3358.                         
  3359.             pd.getCorrelazioneApplicativaRisposta().setElementoList(correlazioni);
  3360.             
  3361.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);
  3362.                     
  3363.             context.getLogger().info("Invocazione completata con successo");
  3364.         
  3365.         }
  3366.         catch(javax.ws.rs.WebApplicationException e) {
  3367.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3368.             throw e;
  3369.         }
  3370.         catch(Throwable e) {
  3371.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3372.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3373.         }
  3374.     }
  3375.     
  3376.     /**
  3377.      * Consente di modificare la configurazione relativa alla validazione dei contenuti applicativi
  3378.      *
  3379.      * Questa operazione consente di aggiornare la configurazione relativa alla validazione dei contenuti applicativi
  3380.      *
  3381.      */
  3382.     @Override
  3383.     public void updateFruizioneValidazione(Validazione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String gruppo, String tipoServizio) {
  3384.         IContext context = this.getContext();
  3385.         try {
  3386.             context.getLogger().info("Invocazione in corso ...");     

  3388.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  3389.             context.getLogger().debug("Autorizzazione completata con successo");     
  3390.              
  3391.             BaseHelper.throwIfNull(body);   

  3393.             final FruizioniConfEnv env = new FruizioniConfEnv(context.getServletRequest(), profilo, soggetto, context, erogatore, nome, versione, gruppo, tipoServizio );       
  3394.             final PortaDelegata pd = env.pdCore.getPortaDelegata(env.idPd);
  3395.             
  3396.             // ============================================
  3397.             final String stato = BaseHelper.evalnull( () -> body.getStato().toString());
  3398.             final String tipoValidazione = BaseHelper.evalnull( () -> body.getTipo().toString() );
  3399.             
  3400.             env.requestWrapper.overrideParameter(CostantiControlStation.PARAMETRO_PORTE_XSD, stato);
  3401.             
  3402.             if (!env.pdHelper.validazioneContenutiCheck(TipoOperazione.OTHER, true)) {
  3403.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  3404.             }
  3405.             
  3406.             final ValidazioneContenutiApplicativi vx = new ValidazioneContenutiApplicativi();
  3407.             
  3408.             // Imposto Mtom al valore eventualmente già presente nel db.
  3409.             vx.setAcceptMtomMessage( BaseHelper.evalnull( () -> pd.getValidazioneContenutiApplicativi().getAcceptMtomMessage()) );
  3410.             vx.setStato( StatoFunzionalitaConWarning.toEnumConstant(stato) );
  3411.             vx.setTipo( ValidazioneContenutiApplicativiTipo.toEnumConstant(tipoValidazione) );
  3412.             
  3413.             pd.setValidazioneContenutiApplicativi(vx);
  3414.             // ============================================

  3416.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);        
  3417.             context.getLogger().info("Invocazione completata con successo");
  3418.         
  3419.      
  3420.         }
  3421.         catch(javax.ws.rs.WebApplicationException e) {
  3422.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  3423.             throw e;
  3424.         }
  3425.         catch(Throwable e) {
  3426.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  3427.             throw FaultCode.ERRORE_INTERNO.toException(e);
  3428.         }
  3429.     }
  3430.     
  3431. }
Created with JaCoCo 0.8.8.202204050719