ErogazioniApiServiceImpl.java

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

  22. import java.util.ArrayList;
  23. import java.util.Arrays;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Optional;

  28. import org.apache.commons.lang.StringEscapeUtils;
  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.commons.Filtri;
  31. import org.openspcoop2.core.commons.Liste;
  32. import org.openspcoop2.core.config.Connettore;
  33. import org.openspcoop2.core.config.InvocazioneCredenziali;
  34. import org.openspcoop2.core.config.InvocazioneServizio;
  35. import org.openspcoop2.core.config.PortaApplicativa;
  36. import org.openspcoop2.core.config.PortaApplicativaAzione;
  37. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  38. import org.openspcoop2.core.config.RispostaAsincrona;
  39. import org.openspcoop2.core.config.ServizioApplicativo;
  40. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  41. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  42. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  43. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  44. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  45. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  46. import org.openspcoop2.core.config.rs.server.api.ErogazioniApi;
  47. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  48. import org.openspcoop2.core.config.rs.server.api.impl.IdServizio;
  49. import org.openspcoop2.core.config.rs.server.api.impl.applicativi.ApplicativiEnv;
  50. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  51. import org.openspcoop2.core.config.rs.server.model.ApiDescrizione;
  52. import org.openspcoop2.core.config.rs.server.model.ApiImplAllegato;
  53. import org.openspcoop2.core.config.rs.server.model.ApiImplInformazioniGenerali;
  54. import org.openspcoop2.core.config.rs.server.model.ApiImplInformazioniGeneraliView;
  55. import org.openspcoop2.core.config.rs.server.model.ApiImplUrlInvocazione;
  56. import org.openspcoop2.core.config.rs.server.model.ApiImplUrlInvocazioneView;
  57. import org.openspcoop2.core.config.rs.server.model.ApiImplVersioneApi;
  58. import org.openspcoop2.core.config.rs.server.model.ApiImplVersioneApiView;
  59. import org.openspcoop2.core.config.rs.server.model.ConnettoreApplicativoServer;
  60. import org.openspcoop2.core.config.rs.server.model.ConnettoreConfigurazioneHttpBasic;
  61. import org.openspcoop2.core.config.rs.server.model.ConnettoreEnum;
  62. import org.openspcoop2.core.config.rs.server.model.ConnettoreErogazione;
  63. import org.openspcoop2.core.config.rs.server.model.ConnettoreHttp;
  64. import org.openspcoop2.core.config.rs.server.model.ConnettoreMessageBox;
  65. import org.openspcoop2.core.config.rs.server.model.Erogazione;
  66. import org.openspcoop2.core.config.rs.server.model.ErogazioneModI;
  67. import org.openspcoop2.core.config.rs.server.model.ErogazioneViewItem;
  68. import org.openspcoop2.core.config.rs.server.model.ListaApiImplAllegati;
  69. import org.openspcoop2.core.config.rs.server.model.ListaErogazioni;
  70. import org.openspcoop2.core.config.rs.server.model.ModalitaIdentificazioneAzioneEnum;
  71. import org.openspcoop2.core.config.rs.server.model.OneOfConnettoreErogazioneConnettore;
  72. import org.openspcoop2.core.config.rs.server.model.TipoApiEnum;
  73. import org.openspcoop2.core.constants.TipiConnettore;
  74. import org.openspcoop2.core.id.IDAccordo;
  75. import org.openspcoop2.core.id.IDPortaApplicativa;
  76. import org.openspcoop2.core.id.IDServizio;
  77. import org.openspcoop2.core.id.IDServizioApplicativo;
  78. import org.openspcoop2.core.id.IDSoggetto;
  79. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  80. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  81. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  82. import org.openspcoop2.core.registry.Documento;
  83. import org.openspcoop2.core.registry.Soggetto;
  84. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  85. import org.openspcoop2.core.registry.beans.OperationSintetica;
  86. import org.openspcoop2.core.registry.beans.PortTypeSintetico;
  87. import org.openspcoop2.core.registry.constants.ServiceBinding;
  88. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  89. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  90. import org.openspcoop2.protocol.sdk.constants.ConsoleInterfaceType;
  91. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  92. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  93. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  94. import org.openspcoop2.utils.UtilsException;
  95. import org.openspcoop2.utils.service.BaseImpl;
  96. import org.openspcoop2.utils.service.authorization.AuthorizationConfig;
  97. import org.openspcoop2.utils.service.authorization.AuthorizationManager;
  98. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  99. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  100. import org.openspcoop2.utils.service.beans.utils.ListaUtils;
  101. import org.openspcoop2.utils.service.context.IContext;
  102. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  103. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  104. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  105. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaUtilities;
  106. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  107. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  108. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiUtilities;
  109. import org.openspcoop2.web.lib.mvc.ServletUtils;
  110. import org.openspcoop2.web.lib.mvc.TipoOperazione;

  112. /**
  113.  * ErogazioniApiServiceImpl
  114.  * 
  115.  * @author $Author$
  116.  * @version $Rev$, $Date$
  117.  * 
  118.  */
  119. public class ErogazioniApiServiceImpl extends BaseImpl implements ErogazioniApi {

  121.     public ErogazioniApiServiceImpl() {
  122.         super(org.slf4j.LoggerFactory.getLogger(ErogazioniApiServiceImpl.class));
  123.     }

  125.     private AuthorizationConfig getAuthorizationConfig() throws Exception {
  126.         return new AuthorizationConfig(ServerProperties.getInstance().getProperties());
  127.     }

  129.     /**
  130.      * Creazione di un'erogazione di API
  131.      *
  132.      * Questa operazione consente di creare una erogazione di API
  133.      *
  134.      */
  135.     @Override
  136.     public void createErogazione(Erogazione body, ProfiloEnum profilo, String soggetto) {

  138.         IContext context = this.getContext();
  139.         try {
  140.             context.getLogger().info("Invocazione in corso ...");

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

  145.             BaseHelper.throwIfNull(body);

  147.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  148.             final Soggetto soggettoErogatore = env.soggettiCore.getSoggettoRegistro(env.idSoggetto.toIDSoggetto());

  150.             final IDSoggetto idReferente = ErogazioniApiHelper.getIdReferente(body, env);
  151.             final AccordoServizioParteComuneSintetico as = Helper.getAccordoSintetico(body.getApiNome(),
  152.                     body.getApiVersione(), idReferente, env.apcCore);

  154.             String referente = "";
  155.             if( env.apcCore.isSupportatoSoggettoReferente(env.tipo_protocollo) && idReferente!=null ){
  156.                 referente = " (referente: "+idReferente+")";
  157.             }

  159.             if (as == null) {
  160.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  161.                         "Nessuna Api registrata con nome " + body.getApiNome() + " e versione " + body.getApiVersione()+referente);
  162.             }
  163.             if(ServiceBinding.SOAP.equals(as.getServiceBinding())) {
  164.                 if(StringUtils.isEmpty(body.getApiSoapServizio())) {
  165.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  166.                             "Per una API di tipo SOAP il claim 'api_soap_servizio' deve essere obbligatoriamente fornito");
  167.                 }
  168.                 boolean ptFind = false;
  169.                 if(as.getPortType()!=null && !as.getPortType().isEmpty()) {
  170.                     for (PortTypeSintetico pt : as.getPortType()) {
  171.                         if(pt.getNome().equals(body.getApiSoapServizio())) {
  172.                             ptFind = true;
  173.                             break;
  174.                         }
  175.                     }
  176.                 }
  177.                 if(!ptFind) {
  178.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  179.                             "Nel claim 'api_soap_servizio' è stato indicato un servizio non esistente nell'API "+body.getApiNome()+" v"+body.getApiVersione()+referente);
  180.                 }
  181.             }

  183.             AccordoServizioParteSpecifica asps = ErogazioniApiHelper.apiImplToAps(body, soggettoErogatore, as, env);
  184.             final IDServizio idAps = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(),
  185.                     new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione());
  186.             boolean alreadyExists = env.apsCore.existsAccordoServizioParteSpecifica(idAps);

  188.             if (alreadyExists) {
  189.                 asps = env.apsCore.getServizio(idAps);
  190.             }

  192.             ProtocolProperties protocolProperties = null;
  193.             if(profilo != null) {
  194.                 AccordoServizioParteComune accordoFull = null;
  195.                 boolean required = false;
  196.                 
  197.                 if(env.isProfiloModi()) {
  198.                     accordoFull = Helper.getAccordoFull(body.getApiNome(),
  199.                             body.getApiVersione(), idReferente, env.apcCore);
  200.                     
  201.                     if(accordoFull.sizeProtocolPropertyList()>0) {
  202.                         for (org.openspcoop2.core.registry.ProtocolProperty pp : accordoFull.getProtocolPropertyList()) {
  203.                             if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO.equals(pp.getName())) {
  204.                                 String v = pp.getValue();
  205.                                 if(v!=null && StringUtils.isNotEmpty(v) && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_UNDEFINED.equals(v)) {
  206.                                     required = true;
  207.                                 }
  208.                             }
  209.                         }
  210.                     }
  211.                 }
  212.                 
  213.                 protocolProperties = ErogazioniApiHelper.getProtocolProperties(body, profilo, accordoFull, asps, env, required);

  215.                 if(protocolProperties != null) {
  216.                     asps.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  217.                 }
  218.             }


  221.             ServletUtils.setObjectIntoSession(context.getServletRequest(), context.getServletRequest().getSession(),
  222.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE,
  223.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);

  225.             ErogazioniApiHelper.serviziCheckData(TipoOperazione.ADD, env, as, asps, Optional.empty(), body);
  226.             ErogazioniApiHelper.validateProperties(env, protocolProperties, asps, ConsoleOperationType.ADD);

  228.             org.openspcoop2.core.registry.Connettore regConnettore = ErogazioniApiHelper.buildConnettoreRegistro(env,
  229.                     body.getConnettore());
  230.             ErogazioniApiHelper.createAps(env, asps, regConnettore, body, alreadyExists, true);

  232.             context.getLogger().info("Invocazione completata con successo");

  234.             // Bug Fix: altrimenti viene generato 204
  235.             context.getServletResponse().setStatus(201);

  237.         } catch (javax.ws.rs.WebApplicationException e) {
  238.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  239.             throw e;
  240.         } catch (Throwable e) {
  241.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  242.             throw FaultCode.ERRORE_INTERNO.toException(e);
  243.         }
  244.     }

  246.     /**
  247.      * Creazione di un allegato nell'erogazione di API
  248.      *
  249.      * Questa operazione consente di aggiungere un allegato all'erogazione di API
  250.      * identificata dal nome e dalla versione
  251.      *
  252.      */
  253.     @Override
  254.     public void createErogazioneAllegato(ApiImplAllegato body, String nome, Integer versione, ProfiloEnum profilo,
  255.             String soggetto, String tipoServizio) {
  256.         IContext context = this.getContext();
  257.         try {
  258.             context.getLogger().info("Invocazione in corso ...");

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

  263.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);

  265.             AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  266.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  268.             ErogazioniApiHelper.createAllegatoAsps(body, env, asps);
  269.             context.getLogger().info("Invocazione completata con successo");

  271.             // Bug Fix: altrimenti viene generato 204
  272.             context.getServletResponse().setStatus(201);

  274.         } catch (javax.ws.rs.WebApplicationException e) {
  275.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  276.             throw e;
  277.         } catch (Throwable e) {
  278.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  279.             throw FaultCode.ERRORE_INTERNO.toException(e);
  280.         }
  281.     }

  283.     /**
  284.      * Elimina un'erogazione di api
  285.      *
  286.      * Questa operazione consente di eliminare un'erogazione di API identificata dal
  287.      * nome e dalla versione
  288.      *
  289.      */
  290.     @Override
  291.     public void deleteErogazione(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  292.             String tipoServizio) {
  293.         IContext context = this.getContext();
  294.         try {
  295.             context.getLogger().info("Invocazione in corso ...");

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

  300.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  301.             final AccordoServizioParteSpecifica asps = BaseHelper.evalnull(() -> ErogazioniApiHelper
  302.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env));

  304.             if (asps != null) {

  306.                 final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  307.                 final StringBuilder inUsoMessage = new StringBuilder();

  309.                 AccordiServizioParteSpecificaUtilities.deleteAccordoServizioParteSpecifica(asps, false, // gestioneFruitori,
  310.                         true, // gestioneErogatori,
  311.                         null, // idSoggettoFruitore
  312.                         idServizio, env.paCore.getExtendedServletPortaApplicativa(), env.userLogin, env.apsCore, env.apsHelper,
  313.                         inUsoMessage, "\n");

  315.                 if (inUsoMessage.length() > 0) {
  316.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(inUsoMessage.toString()));
  317.                 }
  318.             } else if (env.delete_404) {
  319.                 throw FaultCode.NOT_FOUND.toException("Erogazione non presente");
  320.             }

  322.             context.getLogger().info("Invocazione completata con successo");

  324.         } catch (javax.ws.rs.WebApplicationException e) {
  325.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  326.             throw e;
  327.         } catch (Throwable e) {
  328.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  329.             throw FaultCode.ERRORE_INTERNO.toException(e);
  330.         }
  331.     }

  333.     /**
  334.      * Elimina un allegato dall'erogazione
  335.      *
  336.      * Questa operazione consente di eliminare un'allegato dell'erogazione di API
  337.      * identificata dal nome e dalla versione
  338.      *
  339.      */
  340.     @Override
  341.     public void deleteErogazioneAllegato(String nome, Integer versione, String nomeAllegato, ProfiloEnum profilo,
  342.             String soggetto, String tipoServizio) {
  343.         IContext context = this.getContext();
  344.         try {
  345.             context.getLogger().info("Invocazione in corso ...");

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

  350.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  351.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  352.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  353.             ErogazioniApiHelper.deleteAllegato(nomeAllegato, env, asps);

  355.             context.getLogger().info("Invocazione completata con successo");

  357.         } catch (javax.ws.rs.WebApplicationException e) {
  358.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  359.             throw e;
  360.         } catch (Throwable e) {
  361.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  362.             throw FaultCode.ERRORE_INTERNO.toException(e);
  363.         }
  364.     }

  366.     /**
  367.      * Restituisce l'allegato di una erogazione
  368.      *
  369.      * Questa operazione consente di ottenere l'allegato di un'erogazione di API
  370.      * identificata dal nome e dalla versione
  371.      *
  372.      */
  373.     @Override
  374.     public byte[] downloadErogazioneAllegato(String nome, Integer versione, String nomeAllegato, ProfiloEnum profilo,
  375.             String soggetto, String tipoServizio) {
  376.         IContext context = this.getContext();
  377.         try {
  378.             context.getLogger().info("Invocazione in corso ...");

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

  383.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  384.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  385.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  387.             final Optional<Long> idDoc = ErogazioniApiHelper.getIdDocumento(nomeAllegato, asps);

  389.             if (!idDoc.isPresent())
  390.                 throw FaultCode.NOT_FOUND.toException("Allegato di nome " + nomeAllegato + " non presente.");

  392.             final Documento allegato = env.archiviCore.getDocumento(idDoc.get(), true);

  394.             context.getLogger().info("Invocazione completata con successo");

  396.             Helper.setContentType(context, allegato.getFile());

  398.             return allegato.getByteContenuto();

  400.         } catch (javax.ws.rs.WebApplicationException e) {
  401.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  402.             throw e;
  403.         } catch (Throwable e) {
  404.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  405.             throw FaultCode.ERRORE_INTERNO.toException(e);
  406.         }
  407.     }

  409.     /**
  410.      * Ricerca erogazioni di api
  411.      *
  412.      * Elenca le erogazioni di API
  413.      *
  414.      */
  415.     @Override
  416.     public ListaErogazioni findAllErogazioni(ProfiloEnum profilo, String soggetto, String q, Integer limit,
  417.             Integer offset, TipoApiEnum tipoApi, String tag, String uriApiImplementata, Boolean profiloQualsiasi, Boolean soggettoQualsiasi) {
  418.         IContext context = this.getContext();
  419.         try {
  420.             context.getLogger().info("Invocazione in corso ...");

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

  425.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  426.             final int idLista = Liste.SERVIZI;
  427.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  428.                     env.tipo_protocollo);

  430.             if(profiloQualsiasi!=null && profiloQualsiasi) {
  431.                 ricerca.clearFilter(idLista, Filtri.FILTRO_PROTOCOLLO);
  432.             }
  433.             if(soggettoQualsiasi!=null && soggettoQualsiasi) {
  434.                 ricerca.clearFilter(idLista, Filtri.FILTRO_SOGGETTO);
  435.             }

  437.             if (tipoApi != null)
  438.                 ricerca.addFilter(idLista, Filtri.FILTRO_SERVICE_BINDING, tipoApi.toString().toLowerCase());

  440.             if(tag!=null) {
  441.                 ricerca.addFilter(idLista, Filtri.FILTRO_GRUPPO, tag);
  442.             }

  444.             if(uriApiImplementata!=null) {
  445.                 ErogazioniApiHelper.setFiltroApiImplementata(uriApiImplementata, idLista, ricerca, env);
  446.             }

  448.             List<AccordoServizioParteSpecifica> lista = env.apsCore.soggettiServizioList(null, ricerca, null, false, true);

  450.             if (env.findall_404 && lista.isEmpty()) {
  451.                 throw FaultCode.NOT_FOUND.toException("Nessuna erogazione presente");
  452.             }

  454.             final ListaErogazioni ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(),
  455.                     ricerca.getIndexIniziale(idLista),
  456.                     ricerca.getPageSize(idLista), 
  457.                     ricerca.getNumEntries(idLista), ListaErogazioni.class);

  459.             lista.forEach(asps -> {
  460.                 ret.addItemsItem(ErogazioniApiHelper
  461.                         .erogazioneViewItemToErogazioneItem(ErogazioniApiHelper.aspsToErogazioneViewItem(env, asps)));
  462.             });

  464.             context.getLogger().info("Invocazione completata con successo");

  466.             return Helper.returnOrNotFound(ret);

  468.         } catch (javax.ws.rs.WebApplicationException e) {
  469.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  470.             throw e;
  471.         } catch (Throwable e) {
  472.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  473.             throw FaultCode.ERRORE_INTERNO.toException(e);
  474.         }
  475.     }

  477.     /**
  478.      * Elenco allegati di un'erogazione di API
  479.      *
  480.      * Questa operazione consente di ottenere gli allegati di un'erogazione di API
  481.      * identificata dal nome e dalla versione
  482.      *
  483.      */
  484.     @Override
  485.     public ListaApiImplAllegati findAllErogazioneAllegati(String nome, Integer versione, ProfiloEnum profilo,
  486.             String soggetto, String tipoServizio, String q, Integer limit, Integer offset) {
  487.         IContext context = this.getContext();
  488.         try {
  489.             context.getLogger().info("Invocazione in corso ...");

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

  494.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  495.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  496.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  497.             ListaApiImplAllegati ret = ErogazioniApiHelper.findAllAllegati(q, limit, offset,
  498.                     context.getUriInfo(), env, asps);

  500.             context.getLogger().info("Invocazione completata con successo");
  501.             return ret;

  503.         } catch (javax.ws.rs.WebApplicationException e) {
  504.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  505.             throw e;
  506.         } catch (Throwable e) {
  507.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  508.             throw FaultCode.ERRORE_INTERNO.toException(e);
  509.         }
  510.     }

  512.     /**
  513.      * Restituisce i dettagli di un'erogazione di API
  514.      *
  515.      * Questa operazione consente di ottenere i dettagli di una erogazione di API
  516.      * identificata dal nome e dalla versione
  517.      *
  518.      */
  519.     @Override
  520.     public ErogazioneViewItem getErogazione(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  521.             String tipoServizio) {
  522.         IContext context = this.getContext();
  523.         try {
  524.             context.getLogger().info("Invocazione in corso ...");

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

  529.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  530.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  531.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  533.             ErogazioneViewItem ret = ErogazioniApiHelper.aspsToErogazioneViewItem(env, asps);

  535.             context.getLogger().info("Invocazione completata con successo");

  537.             return ret;

  539.         } catch (javax.ws.rs.WebApplicationException e) {
  540.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  541.             throw e;
  542.         } catch (Throwable e) {
  543.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  544.             throw FaultCode.ERRORE_INTERNO.toException(e);
  545.         }
  546.     }

  548.     /**
  549.      * Restituisce le informazioni sull'API implementata dall'erogazione
  550.      *
  551.      * Questa operazione consente di ottenere le informazioni sull'API implementata
  552.      * dall'erogazione identificata dal nome e dalla versione
  553.      *
  554.      */
  555.     @Override
  556.     public ApiImplVersioneApiView getErogazioneAPI(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  557.             String tipoServizio) {
  558.         IContext context = this.getContext();
  559.         try {
  560.             context.getLogger().info("Invocazione in corso ...");

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

  565.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  566.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  567.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  568.             ApiImplVersioneApiView ret = ErogazioniApiHelper.aspsToApiImplVersioneApiView(env, asps);

  570.             context.getLogger().info("Invocazione completata con successo");
  571.             return ret;

  573.         } catch (javax.ws.rs.WebApplicationException e) {
  574.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  575.             throw e;
  576.         } catch (Throwable e) {
  577.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  578.             throw FaultCode.ERRORE_INTERNO.toException(e);
  579.         }
  580.     }

  582.     /**
  583.      * Restituisce il dettaglio di un allegato dell'erogazione
  584.      *
  585.      * Questa operazione consente di ottenere il dettaglio di un allegato
  586.      * dell'erogazione di API identificata dal nome e dalla versione
  587.      *
  588.      */
  589.     @Override
  590.     public ApiImplAllegato getErogazioneAllegato(String nome, Integer versione, String nomeAllegato, ProfiloEnum profilo,
  591.             String soggetto, String tipoServizio) {
  592.         IContext context = this.getContext();
  593.         try {
  594.             context.getLogger().info("Invocazione in corso ...");

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

  599.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  600.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  601.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  603.             final Optional<Long> idDoc = ErogazioniApiHelper.getIdDocumento(nomeAllegato, asps);

  605.             if (!idDoc.isPresent())
  606.                 throw FaultCode.NOT_FOUND.toException("Allegato di nome " + nomeAllegato + " non presente.");

  608.             final Documento doc = env.archiviCore.getDocumento(idDoc.get(), true);

  610.             context.getLogger().info("Invocazione completata con successo");

  612.             return ErogazioniApiHelper.documentoToImplAllegato(doc);

  614.         } catch (javax.ws.rs.WebApplicationException e) {
  615.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  616.             throw e;
  617.         } catch (Throwable e) {
  618.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  619.             throw FaultCode.ERRORE_INTERNO.toException(e);
  620.         }
  621.     }

  623.     /**
  624.      * Restituisce le informazioni su connettore associato all'erogazione
  625.      *
  626.      * Questa operazione consente di ottenere le informazioni sul connettore
  627.      * associato all'erogazione identificata dal nome e dalla versione
  628.      *
  629.      */
  630.     @Override
  631.     public ConnettoreErogazione getErogazioneConnettore(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  632.             String tipoServizio, String gruppo) {
  633.         IContext context = this.getContext();
  634.         try {
  635.             context.getLogger().info("Invocazione in corso ...");

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


  641.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  642.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  643.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  645.             IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());

  647.             final ConnettoreErogazione ret;
  648.             if(ErogazioniApiHelper.isConnettoreApplicativoServer(idAsps, env.idServizioFactory.getIDServizioFromAccordo(asps), env, gruppo)) {

  650.                 ServizioApplicativo sa = ErogazioniApiHelper.getServizioApplicativo(idAsps, env.idServizioFactory.getIDServizioFromAccordo(asps), env, gruppo);
  651.                 ret = new ConnettoreErogazione();
  652.                 ConnettoreApplicativoServer con = new ConnettoreApplicativoServer();
  653.                 con.setTipo(ConnettoreEnum.APPLICATIVO_SERVER);
  654.                 con.setApplicativo(sa.getNome());
  655.                 ret.setConnettore(con);

  657.             } else {
  658.                 ServizioApplicativo sa = ErogazioniApiHelper
  659.                         .getServizioApplicativo(idAsps, env.idServizioFactory.getIDServizioFromAccordo(asps), env, gruppo);

  661.                 ret = ConnettoreAPIHelper.buildConnettoreErogazione(sa);

  663.             }

  665.             context.getLogger().info("Invocazione completata con successo");
  666.             return ret;

  668.         } catch (javax.ws.rs.WebApplicationException e) {
  669.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  670.             throw e;
  671.         } catch (Throwable e) {
  672.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  673.             throw FaultCode.ERRORE_INTERNO.toException(e);
  674.         }
  675.     }

  677.     /**
  678.      * Restituisce la descrizione di una erogazione
  679.      *
  680.      * Questa operazione consente di ottenere la descrizione di una erogazione identificata dal nome e dalla versione
  681.      *
  682.      */
  683.     @Override
  684.     public ApiDescrizione getErogazioneDescrizione(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  685.         IContext context = this.getContext();
  686.         try {
  687.             context.getLogger().info("Invocazione in corso ...");     

  689.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  690.             context.getLogger().debug("Autorizzazione completata con successo");     
  691.                         
  692.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  693.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  694.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  695.             
  696.             ApiDescrizione descr = new ApiDescrizione();
  697.             descr.setDescrizione(asps.getDescrizione());
  698.             
  699.             context.getLogger().info("Invocazione completata con successo");
  700.             return descr;
  701.      
  702.         }
  703.         catch(javax.ws.rs.WebApplicationException e) {
  704.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  705.             throw e;
  706.         }
  707.         catch(Throwable e) {
  708.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  709.             throw FaultCode.ERRORE_INTERNO.toException(e);
  710.         }
  711.     }

  713.     /**
  714.      * Restituisce le informazioni generali di un'erogazione di API
  715.      *
  716.      * Questa operazione consente di ottenere le informazioni generali di
  717.      * un'erogazione di API identificata dal nome e dalla versione
  718.      *
  719.      */
  720.     @Override
  721.     public ApiImplInformazioniGeneraliView getErogazioneInformazioniGenerali(String nome, Integer versione,
  722.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  723.         IContext context = this.getContext();
  724.         try {
  725.             context.getLogger().info("Invocazione in corso ...");

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

  730.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  731.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  732.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  734.             ApiImplInformazioniGeneraliView ret = ErogazioniApiHelper.erogazioneToApiImplInformazioniGeneraliView(env, asps);

  736.             context.getLogger().info("Invocazione completata con successo");
  737.             return ret;

  739.         } catch (javax.ws.rs.WebApplicationException e) {
  740.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  741.             throw e;
  742.         } catch (Throwable e) {
  743.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  744.             throw FaultCode.ERRORE_INTERNO.toException(e);
  745.         }
  746.     }


  749.     /**
  750.      * Restituisce le informazioni ModI associate all&#x27;erogazione
  751.      *
  752.      * Questa operazione consente di ottenere le informazioni modI associate all&#x27;erogazione identificata dal nome e dalla versione
  753.      *
  754.      */
  755.     @Override
  756.     public ErogazioneModI getErogazioneModI(String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  757.         IContext context = this.getContext();
  758.         try {
  759.             context.getLogger().info("Invocazione in corso ...");     

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

  764.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  765.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  766.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  768.             final IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  769.             final AccordoServizioParteComune aspc = Helper.getAccordoFull(idAccordo.getNome(),
  770.                     idAccordo.getVersione(), idAccordo.getSoggettoReferente(), env.apcCore);
  771.             
  772.             ErogazioneModI ret = ModiErogazioniApiHelper.getErogazioneModi(aspc, asps, env, profilo, ErogazioniApiHelper.getProtocolPropertiesMap(asps, env));

  774.             context.getLogger().info("Invocazione completata con successo");
  775.             return ret;

  777.         }
  778.         catch(javax.ws.rs.WebApplicationException e) {
  779.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  780.             throw e;
  781.         }
  782.         catch(Throwable e) {
  783.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  784.             throw FaultCode.ERRORE_INTERNO.toException(e);
  785.         }
  786.     }

  788.     /**
  789.      * Restituisce le informazioni sull'url di invocazione necessaria ad invocare
  790.      * l'erogazione
  791.      *
  792.      * Questa operazione consente di ottenere le informazioni sull'url di
  793.      * invocazione necessaria ad invocare l'erogazione identificata dal nome e dalla
  794.      * versione
  795.      *
  796.      */
  797.     @Override
  798.     public ApiImplUrlInvocazioneView getErogazioneUrlInvocazione(String nome, Integer versione, ProfiloEnum profilo,
  799.             String soggetto, String tipoServizio) {
  800.         IContext context = this.getContext();
  801.         try {
  802.             context.getLogger().info("Invocazione in corso ...");

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

  807.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  808.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  809.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  810.             final PortaApplicativa pa = env.paCore.getPortaApplicativa(
  811.                     env.paCore.getIDPortaApplicativaAssociataDefault(env.idServizioFactory.getIDServizioFromAccordo(asps)));
  812.             final PortaApplicativaAzione paAzione = pa.getAzione();
  813.             final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());

  815.             String urlInvocazione = ErogazioniApiHelper.getUrlInvocazioneErogazione(asps, env);
  816.             ApiImplUrlInvocazioneView ret = new ApiImplUrlInvocazioneView();

  818.             // Come prendo le azioni del gruppo predefinito?

  820.             Map<String, String> azioni = env.paCore.getAzioniConLabel(asps, aspc, false, true, new ArrayList<>());
  821.             ret.setAzioni(Arrays.asList(azioni.keySet().toArray(new String[azioni.size()])));
  822.             ret.setForceInterface(Helper.statoFunzionalitaConfToBool(paAzione.getForceInterfaceBased()));
  823.             ret.setModalita(Enum.valueOf(ModalitaIdentificazioneAzioneEnum.class, paAzione.getIdentificazione().name()));
  824.             switch (ret.getModalita()) {
  825.             case CONTENT_BASED:
  826.             case URL_BASED:
  827.                 ret.setPattern(paAzione.getPattern());
  828.                 break;
  829.             case HEADER_BASED:
  830.                 ret.setNome(paAzione.getPattern());
  831.                 break;
  832.             case INPUT_BASED:
  833.             case PROTOCOL_BASED:
  834.             case SOAP_ACTION_BASED:
  835.                 break;
  836.             case STATIC:
  837.             case INTERFACE_BASED:
  838.                 ret.setForceInterface(false);
  839.                 break;
  840.             }
  841.             ret.setUrlInvocazione(urlInvocazione);

  843.             context.getLogger().info("Invocazione completata con successo");
  844.             return ret;
  845.         } catch (javax.ws.rs.WebApplicationException e) {
  846.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  847.             throw e;
  848.         } catch (Throwable e) {
  849.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  850.             throw FaultCode.ERRORE_INTERNO.toException(e);
  851.         }
  852.     }

  854.     /**
  855.      * Consente di modificare la versione dell'API implementata dall'erogazione
  856.      *
  857.      * Questa operazione consente di aggiornare la versione dell'API implementata
  858.      * dall'erogazione identificata dal nome e dalla versione
  859.      *
  860.      */
  861.     @Override
  862.     public void updateErogazioneAPI(ApiImplVersioneApi body, String nome, Integer versione, ProfiloEnum profilo,
  863.             String soggetto, String tipoServizio) {
  864.         IContext context = this.getContext();
  865.         try {
  866.             context.getLogger().info("Invocazione in corso ...");

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

  871.             BaseHelper.throwIfNull(body);

  873.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  874.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  875.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  876.             final AccordoServizioParteComuneSintetico as = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());

  878.             List<AccordoServizioParteComune> asParteComuneCompatibili = env.apsCore.findAccordiParteComuneBySoggettoAndNome(
  879.                     as.getNome(), new IDSoggetto(as.getSoggettoReferente().getTipo(), as.getSoggettoReferente().getNome()));

  881.             Optional<AccordoServizioParteComune> newApc = BaseHelper.findFirst(asParteComuneCompatibili,
  882.                     a -> (a.getVersione()!=null && body.getApiVersione()!=null && (a.getVersione().intValue() == body.getApiVersione().intValue())));

  884.             if (!newApc.isPresent()) {
  885.                 throw FaultCode.RICHIESTA_NON_VALIDA
  886.                 .toException("Nessuna api " + as.getNome() + " e versione " + body.getApiVersione() + " registrata");
  887.             }

  889.             asps.setAccordoServizioParteComune(env.idAccordoFactory.getUriFromAccordo(newApc.get()));
  890.             asps.setIdAccordo(newApc.get().getId());

  892.             asps.setOldIDServizioForUpdate(env.idServizioFactory.getIDServizioFromAccordo(asps));

  894.             ErogazioniApiHelper.serviziUpdateCheckData(as, asps, true, env);

  896.             List<Object> oggettiDaAggiornare = AccordiServizioParteSpecificaUtilities.getOggettiDaAggiornare(asps,
  897.                     env.apsCore);

  899.             env.apsCore.performUpdateOperation(env.userLogin, false, oggettiDaAggiornare.toArray());

  901.             context.getLogger().info("Invocazione completata con successo");
  902.         } catch (javax.ws.rs.WebApplicationException e) {
  903.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  904.             throw e;
  905.         } catch (Throwable e) {
  906.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  907.             throw FaultCode.ERRORE_INTERNO.toException(e);
  908.         }
  909.     }

  911.     /**
  912.      * Modifica i dati di un allegato dell'erogazione
  913.      *
  914.      * Questa operazione consente di aggiornare i dettagli di un allegato
  915.      * dell'erogazione di API identificata dal nome e dalla versione
  916.      *
  917.      */
  918.     @Override
  919.     public void updateErogazioneAllegato(ApiImplAllegato body, String nome, Integer versione, String nomeAllegato,
  920.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  921.         IContext context = this.getContext();
  922.         try {
  923.             context.getLogger().info("Invocazione in corso ...");

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

  928.             BaseHelper.throwIfNull(body);

  930.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  931.             AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  932.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  934.             ErogazioniApiHelper.updateAllegatoAsps(body, nomeAllegato, env, asps);

  936.             context.getLogger().info("Invocazione completata con successo");
  937.         } catch (javax.ws.rs.WebApplicationException e) {
  938.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  939.             throw e;
  940.         } catch (Throwable e) {
  941.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  942.             throw FaultCode.ERRORE_INTERNO.toException(e);
  943.         }
  944.     }

  946.     /**
  947.      * Consente di modificare la configurazione del connettore associato
  948.      * all'erogazione
  949.      *
  950.      * Questa operazione consente di aggiornare la configurazione del connettore
  951.      * associato all'erogazione identificata dal nome e dalla versione
  952.      *
  953.      */
  954.     @Override
  955.     public void updateErogazioneConnettore(ConnettoreErogazione body, String nome, Integer versione, ProfiloEnum profilo,
  956.             String soggetto, String tipoServizio, String gruppo) {
  957.         IContext context = this.getContext();
  958.         try {
  959.             context.getLogger().info("Invocazione in corso ...");

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

  964.             if (body == null)
  965.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  967.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);

  969.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  970.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  972.             IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());

  974.             IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  975.             IDPortaApplicativa idPaDefault = env.paCore.getIDPortaApplicativaAssociataDefault(idServizio);
  976.             final PortaApplicativa paDefault = env.paCore.getPortaApplicativa(idPaDefault);

  978.             boolean creaNuovoConnettore = false;
  979.             IDPortaApplicativa idPa = null;
  980.             PortaApplicativa pa;

  982.             if(gruppo != null) {
  983.                 idPa = BaseHelper.supplyOrNonValida( () -> ErogazioniApiHelper.getIDGruppoPA(gruppo, idAsps, env.apsCore), "Gruppo per l'erogazione scelta");
  984.                 pa = env.paCore.getPortaApplicativa(idPa);

  986.                 creaNuovoConnettore = !env.apsHelper.isConnettoreRidefinito(paDefault, paDefault.getServizioApplicativoList().get(0), pa, 
  987.                         pa.getServizioApplicativoList().get(0), pa.getServizioApplicativoList());
  988.             } else {
  989.                 idPa = idPaDefault;
  990.                 pa = paDefault;
  991.             }

  993.             if(this.isConnettoreMessageBox(body.getConnettore(), profilo, soggetto, context)) {

  995.                 // permesso solo su API SOAP e su PA con tutte e sole azioni oneway
  996.                 AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  997.                 
  998.                 org.openspcoop2.message.constants.ServiceBinding serviceBinding = env.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  999.                 MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa = env.paCore.getMappingErogazionePortaApplicativa(pa);
  1000.                 boolean isSoapOneWay = env.saHelper.isSoapOneWay(pa, mappingErogazionePortaApplicativa, asps, apc, serviceBinding);
  1001.                 if(!isSoapOneWay) {
  1002.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Impossibile associare un connettore di tipo message-box a una erogazione (o gruppo) che non sia composto da tutte e sole Operation SOAP OneWay");
  1003.                 }
  1004.             }

  1006.             String erogazioneServizioApplicativoServer = null;
  1007.             if(body.getConnettore().getTipo().equals(ConnettoreEnum.APPLICATIVO_SERVER)) {
  1008.                 ConnettoreApplicativoServer connAppServer = (ConnettoreApplicativoServer) body.getConnettore();

  1010.                 erogazioneServizioApplicativoServer = connAppServer.getApplicativo();

  1012.                 IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  1013.                 idServizioApplicativo.setIdSoggettoProprietario(env.idSoggetto.toIDSoggetto());
  1014.                 idServizioApplicativo.setNome(erogazioneServizioApplicativoServer);
  1015.                 ServizioApplicativo sa = env.saCore.getServizioApplicativo(idServizioApplicativo);

  1017.                 if(!ErogazioniApiHelper.isConnettoreApplicativoServer(sa)) {
  1018.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Applicativo ["+connAppServer.getApplicativo()+"] non di tipo server: " + sa.getTipo());
  1019.                 }
  1020.             }

  1022.             ServizioApplicativo sa = null;
  1023.             if(creaNuovoConnettore) {
  1024.                 // crea sa e associa connettore

  1026.                 List<Object> listaOggettiDaCreare = new ArrayList<>();
  1027.                 List<Object> listaOggettiDaModificare = new ArrayList<>();

  1029.                 // creare un servizio applicativo
  1030.                 String nomeServizioApplicativoErogatore = pa.getNome();

  1032.                 sa = new ServizioApplicativo();
  1033.                 sa.setNome(nomeServizioApplicativoErogatore);
  1034.                 sa.setTipologiaFruizione(TipologiaFruizione.DISABILITATO.getValue());
  1035.                 sa.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  1036.                 sa.setIdSoggetto(pa.getIdSoggetto());
  1037.                 sa.setTipoSoggettoProprietario(pa.getTipoSoggettoProprietario());
  1038.                 sa.setNomeSoggettoProprietario(pa.getNomeSoggettoProprietario());

  1040.                 RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  1041.                 rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  1042.                 rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  1043.                 Connettore conn = new Connettore();
  1044.                 conn.setTipo(TipiConnettore.DISABILITATO.toString());
  1045.                 rispostaAsinc.setConnettore(conn);
  1046.                 sa.setRispostaAsincrona(rispostaAsinc);

  1048.                 InvocazioneServizio invServizio = new InvocazioneServizio();
  1049.                 invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  1050.                 invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  1051.                 Connettore conn1 = new Connettore();
  1052.                 conn1.setTipo(TipiConnettore.DISABILITATO.toString());
  1053.                 invServizio.setConnettore(conn1);
  1054.                 sa.setInvocazioneServizio(invServizio);

  1056.                 listaOggettiDaCreare.add(sa);

  1058.                 pa.getServizioApplicativoList().clear();

  1060.                 PortaApplicativaServizioApplicativo paSA = new PortaApplicativaServizioApplicativo();
  1061.                 paSA.setNome(nomeServizioApplicativoErogatore);
  1062.                 pa.getServizioApplicativoList().add(paSA);

  1064.                 listaOggettiDaModificare.add(pa);

  1066.                 env.paCore.performCreateOperation(env.userLogin, false, listaOggettiDaCreare.toArray());
  1067.                 env.paCore.performUpdateOperation(env.userLogin, false, listaOggettiDaModificare.toArray());
  1068.             }

  1070.             if(sa == null) {
  1071.                 sa = BaseHelper.supplyOrNotFound(() -> env.saCore
  1072.                         .getServizioApplicativo(env.saCore.getIdServizioApplicativo(env.idSoggetto.toIDSoggetto(), pa.getServizioApplicativoList().get(0).getNome())),
  1073.                         "Applicativo");
  1074.             }

  1076.             String oldErogazioneServizioApplicativoServer = null;
  1077.             if(ErogazioniApiHelper.isConnettoreApplicativoServer(sa)) {
  1078.                 oldErogazioneServizioApplicativoServer = sa.getNome();
  1079.             }
  1080.             if(erogazioneServizioApplicativoServer!=null) {

  1082.                 if(oldErogazioneServizioApplicativoServer == null || !erogazioneServizioApplicativoServer.equals(oldErogazioneServizioApplicativoServer)) {

  1084.                     // prelevo l'associazione con il vecchio servizio applicativo
  1085.                     PortaApplicativaServizioApplicativo paSAtmp = null;
  1086.                     for (PortaApplicativaServizioApplicativo paSA : pa.getServizioApplicativoList()) {
  1087.                         if(paSA.getNome().equals(sa.getNome())) {
  1088.                             paSAtmp = paSA;
  1089.                             break;
  1090.                         }
  1091.                     }

  1093.                     if(paSAtmp!= null) {
  1094.                         // se ho modificato il server che sto utilizzando lo rimuovo
  1095.                         if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())){
  1096.                             pa.getServizioApplicativoList().remove(paSAtmp);    
  1097.                         } else {
  1098.                             // SA di default da conservare
  1099.                             pa.getServizioApplicativoList().remove(paSAtmp);
  1100.                             pa.setServizioApplicativoDefault(sa.getNome());
  1101.                         }
  1102.                     }

  1104.                     // nuovo SA da aggiungere
  1105.                     PortaApplicativaServizioApplicativo paSA = new PortaApplicativaServizioApplicativo();
  1106.                     paSA.setNome(erogazioneServizioApplicativoServer);
  1107.                     pa.getServizioApplicativoList().add(paSA);

  1109.                     env.saHelper.impostaSAServerAlleConfigurazioniCheUsanoConnettoreDelMappingDiDefault(asps.getId() + "", erogazioneServizioApplicativoServer, pa, sa, Arrays.asList(pa));
  1110.                     env.paCore.performUpdateOperation(env.userLogin, false, pa);

  1112.                 }

  1114.             } else {

  1116.                 if(oldErogazioneServizioApplicativoServer!=null) {
  1117.                     String oldServizioApplicativoDefault = pa.getServizioApplicativoDefault();
  1118.                     String oldNomeSA = sa.getNome();
  1119.                     String oldTipoSA = sa.getTipo();

  1121.                     // prelevo l'associazione con il vecchio servizio applicativo server
  1122.                     PortaApplicativaServizioApplicativo paSAtmp = null;
  1123.                     for (PortaApplicativaServizioApplicativo paSA : pa.getServizioApplicativoList()) {
  1124.                         if(paSA.getNome().equals(oldNomeSA)) {
  1125.                             paSAtmp = paSA;
  1126.                             break;
  1127.                         }
  1128.                     }

  1130.                     if(paSAtmp!= null) {
  1131.                         // se ho modificato il server che sto utilizzando lo rimuovo
  1132.                         if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(oldTipoSA)){
  1133.                             pa.getServizioApplicativoList().remove(paSAtmp);    
  1134.                         }
  1135.                     }

  1137.                     PortaApplicativaServizioApplicativo paSA = new PortaApplicativaServizioApplicativo();
  1138.                     paSA.setNome(oldServizioApplicativoDefault);
  1139.                     //                  paSA.setNome(pa.getNome());
  1140.                     pa.getServizioApplicativoList().add(paSA);
  1141.                     pa.setServizioApplicativoDefault(null);

  1143.                     env.saHelper.impostaSADefaultAlleConfigurazioniCheUsanoConnettoreDelMappingDiDefault(asps.getId() + "", pa, sa, Arrays.asList(pa));

  1145.                     // rileggo la vecchia configurazione dal db di default
  1146.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  1147.                     idSA.setNome(oldServizioApplicativoDefault);
  1148.                     IDSoggetto idSoggettoProprietario = new IDSoggetto();
  1149.                     idSoggettoProprietario.setTipo(pa.getTipoSoggettoProprietario());
  1150.                     idSoggettoProprietario.setNome(pa.getNomeSoggettoProprietario());
  1151.                     idSA.setIdSoggettoProprietario(idSoggettoProprietario );
  1152.                     sa = env.saCore.getServizioApplicativo(idSA);

  1154.                     env.saCore.performUpdateOperation(env.userLogin, false, pa);
  1155.                 }

  1157.                 InvocazioneServizio is = sa.getInvocazioneServizio();
  1158.                 
  1159.                 String endpointtype = getEndpointType(body.getConnettore());
  1160.                 
  1161.                 org.openspcoop2.core.config.Connettore connis = is.getConnettore();
  1162.                 String oldConnT = connis.getTipo();
  1163.                 if ((connis.getCustom() != null && connis.getCustom())
  1164.                         && !connis.getTipo().equals(TipiConnettore.HTTPS.toString())
  1165.                         && !connis.getTipo().equals(TipiConnettore.FILE.toString())) {
  1166.                     oldConnT = TipiConnettore.CUSTOM.toString();
  1167.                 }
  1168.                 if (!ConnettoreAPIHelper.connettoreCheckData(body.getConnettore(), env, true)) {
  1169.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  1170.                 }

  1172.                 ConnettoreAPIHelper.fillConnettoreConfigurazione(sa, env, body.getConnettore(), oldConnT);
  1173.                 
  1174.                 if(body.getConnettore().getTipo().equals(ConnettoreEnum.HTTP) && ((ConnettoreHttp) body.getConnettore()).getAutenticazioneHttp() != null) {
  1175.                     InvocazioneCredenziali credenziali_is = is.getCredenziali();
  1176.                     if (credenziali_is == null) {
  1177.                         credenziali_is = new InvocazioneCredenziali();
  1178.                     }
  1179.                     
  1180.                     ConnettoreConfigurazioneHttpBasic authHttp = ((ConnettoreHttp) body.getConnettore()).getAutenticazioneHttp();
  1181.                     credenziali_is.setUser(authHttp.getUsername());
  1182.                     credenziali_is.setPassword(authHttp.getPassword());

  1184.                     is.setCredenziali(credenziali_is);
  1185.                     is.setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  1186.                 }

  1188.                 else {
  1189.                     is.setCredenziali(null);
  1190.                     is.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  1191.                 }

  1193.                 is.setConnettore(connis);

  1195.                 sa.setInvocazioneServizio(is);

  1197.                 if (StatoFunzionalita.ABILITATO.equals(is.getGetMessage())
  1198.                         || !TipiConnettore.DISABILITATO.toString().equals(endpointtype)) {
  1199.                     sa.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  1200.                 } else {
  1201.                     sa.setTipologiaErogazione(TipologiaErogazione.DISABILITATO.getValue());
  1202.                 }

  1204.                 StringBuilder inUsoMessage = new StringBuilder();
  1205.                 ServiziApplicativiUtilities.checkStatoConnettore(env.saCore, sa, is.getConnettore(), inUsoMessage, System.lineSeparator());

  1207.                 if (inUsoMessage.length() > 0)
  1208.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(inUsoMessage.toString()));

  1210.                 env.saCore.performUpdateOperation(env.userLogin, false, sa);
  1211.             }

  1213.             context.getLogger().info("Invocazione completata con successo");

  1215.         } catch (javax.ws.rs.WebApplicationException e) {
  1216.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1217.             throw e;
  1218.         } catch (Throwable e) {
  1219.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1220.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1221.         }
  1222.     }

  1224.     private boolean isConnettoreMessageBox(OneOfConnettoreErogazioneConnettore connettore, ProfiloEnum profilo, String soggetto, IContext context) throws UtilsException, Exception {
  1225.         if(connettore instanceof ConnettoreMessageBox) return true;
  1226.         
  1227.         if(!(connettore instanceof ConnettoreApplicativoServer)) return false;
  1228.         
  1229.         ApplicativiEnv env = new ApplicativiEnv(context.getServletRequest(), profilo, soggetto, context);
  1230.         
  1231.         ServizioApplicativo sa = null;          
  1232.         ConnettoreApplicativoServer cas = (ConnettoreApplicativoServer) connettore;
  1233.         try {
  1234.             
  1235.             IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  1236.             idServizioApplicativo.setIdSoggettoProprietario(env.idSoggetto.toIDSoggetto());
  1237.             idServizioApplicativo.setNome(cas.getApplicativo());
  1238.             sa = env.saCore.getServizioApplicativo(idServizioApplicativo);
  1239.             
  1240.             if(!sa.getTipo().equals(CostantiConfigurazione.SERVER)) {
  1241.                 throw new Exception("Applicativo non di tipo server: " + sa.getTipo());
  1242.             }
  1243.             
  1244.             return sa.getInvocazioneServizio().getGetMessage().equals(StatoFunzionalita.ABILITATO);
  1245.         } catch ( Exception e) {
  1246.             throw FaultCode.NOT_FOUND.toException("Applicativo server con nome: " + cas.getApplicativo() + " non trovato.");
  1247.         }

  1249.     }

  1251.     private String getEndpointType(OneOfConnettoreErogazioneConnettore connettore) {
  1252.         switch(connettore.getTipo()) {
  1253.         case APPLICATIVO_SERVER: 
  1254.             //BOH
  1255.         case ECHO:
  1256.             return TipiConnettore.NULLECHO.getNome();
  1257.         case STATUS:
  1258.             return TipiConnettore.STATUS.getNome();
  1259.         case FILE: return TipiConnettore.FILE.getNome();
  1260.         case HTTP:
  1261.             ConnettoreHttp connettoreHttp = (ConnettoreHttp) connettore;
  1262.             String endpointtype = connettoreHttp.getAutenticazioneHttp() != null ? TipiConnettore.HTTP.getNome()
  1263.             : TipiConnettore.DISABILITATO.getNome();
  1264.             return connettoreHttp.getAutenticazioneHttps() != null ? TipiConnettore.HTTPS.getNome() : endpointtype;
  1265.         case JMS:
  1266.             return TipiConnettore.JMS.getNome();
  1267.         case MESSAGE_BOX:
  1268.             break; 
  1269.         case NULL:
  1270.             return TipiConnettore.NULL.getNome();
  1271.         case PLUGIN:
  1272.             return TipiConnettore.CUSTOM.getNome();
  1273.         default:
  1274.             break;}
  1275.         
  1276.         return TipiConnettore.DISABILITATO.getNome();
  1277.     }

  1279.     /**
  1280.      * Consente di modificare la descrizione di una erogazione
  1281.      *
  1282.      * Questa operazione consente di aggiornare la descrizione di una erogazione identificata dal nome e dalla versione
  1283.      *
  1284.      */
  1285.     @Override
  1286.     public void updateErogazioneDescrizione(ApiDescrizione body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1287.         IContext context = this.getContext();
  1288.         try {
  1289.             context.getLogger().info("Invocazione in corso ...");     

  1291.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1292.             context.getLogger().debug("Autorizzazione completata con successo");     
  1293.                         
  1294.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1295.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1296.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");
  1297.             
  1298.             asps.setDescrizione(body.getDescrizione());
  1299.             
  1300.             IDServizio oldIDServizioForUpdate = env.idServizioFactory.getIDServizioFromAccordo(asps);
  1301.             asps.setOldIDServizioForUpdate(oldIDServizioForUpdate);
  1302.             
  1303.             env.apsCore.performUpdateOperation(env.userLogin, false, asps);
  1304.             
  1305.             context.getLogger().info("Invocazione completata con successo");       
  1306.      
  1307.         }
  1308.         catch(javax.ws.rs.WebApplicationException e) {
  1309.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1310.             throw e;
  1311.         }
  1312.         catch(Throwable e) {
  1313.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1314.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1315.         }
  1316.     }

  1318.     /**
  1319.      * Consente di modificare le informazioni generali di un'erogazione di API
  1320.      *
  1321.      * Questa operazione consente di aggiornare le informazioni generali di
  1322.      * un'erogazione di API identificata dal nome e dalla versione
  1323.      *
  1324.      */
  1325.     @Override
  1326.     public void updateErogazioneInformazioniGenerali(ApiImplInformazioniGenerali body, String nome, Integer versione,
  1327.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1328.         IContext context = this.getContext();
  1329.         try {
  1330.             context.getLogger().info("Invocazione in corso ...");

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

  1335.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1336.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1337.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  1339.             ErogazioniApiHelper.updateInformazioniGenerali(body, env, asps, true);

  1341.             context.getLogger().info("Invocazione completata con successo");

  1343.         } catch (javax.ws.rs.WebApplicationException e) {
  1344.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1345.             throw e;
  1346.         } catch (Throwable e) {
  1347.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1348.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1349.         }
  1350.     }

  1352.     /**
  1353.      * Consente di modificare le informazioni ModI associate all&#x27;erogazione
  1354.      *
  1355.      * Questa operazione consente di aggiornare le informazioni ModI assocaite all&#x27;erogazione identificata dal nome e dalla versione
  1356.      *
  1357.      */
  1358.     @Override
  1359.     public void updateErogazioneModI(ErogazioneModI body, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1360.         IContext context = this.getContext();
  1361.         try {
  1362.             context.getLogger().info("Invocazione in corso ...");     

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

  1367.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1368.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1369.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env), "Erogazione");

  1371.             ProtocolProperties protocolProperties = null;
  1372.             if(profilo != null) {
  1373.                 
  1374.                 final IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  1375.                 final AccordoServizioParteComune aspc = Helper.getAccordoFull(idAccordo.getNome(), 
  1376.                         idAccordo.getVersione(), idAccordo.getSoggettoReferente(), env.apcCore);
  1377.             
  1378.                 protocolProperties = ModiErogazioniApiHelper.updateModiProtocolProperties(aspc, asps, profilo, body.getModi(), env);

  1380.                 if(protocolProperties != null) {
  1381.                     asps.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  1382.                 }
  1383.             }

  1385.             asps.setOldIDServizioForUpdate(env.idServizioFactory.getIDServizioFromAccordo(asps));

  1387.             ErogazioniApiHelper.validateProperties(env, protocolProperties, asps, ConsoleOperationType.CHANGE);

  1389.             env.apsCore.setDataAggiornamentoServizio(asps);
  1390.             
  1391.             List<Object> oggettiDaAggiornare = AccordiServizioParteSpecificaUtilities.getOggettiDaAggiornare(asps,
  1392.                     env.apsCore);

  1394.             env.apsCore.performUpdateOperation(env.userLogin, false, oggettiDaAggiornare.toArray());

  1396.             context.getLogger().info("Invocazione completata con successo");
  1397.         }
  1398.         catch(javax.ws.rs.WebApplicationException e) {
  1399.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1400.             throw e;
  1401.         }
  1402.         catch(Throwable e) {
  1403.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1404.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1405.         }
  1406.     }

  1408.     /**
  1409.      * Consente di modificare la configurazione utilizzata per identificare l'azione
  1410.      * invocata dell'API implementata dall'erogazione
  1411.      *
  1412.      * Questa operazione consente di aggiornare la configurazione utilizzata dal
  1413.      * Gateway per identificare l'azione invocata
  1414.      *
  1415.      */
  1416.     @Override
  1417.     public void updateErogazioneUrlInvocazione(ApiImplUrlInvocazione body, String nome, Integer versione,
  1418.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1419.         IContext context = this.getContext();
  1420.         try {
  1421.             context.getLogger().info("Invocazione in corso ...");

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

  1426.             BaseHelper.throwIfNull(body);

  1428.             if (body.getModalita() == null)
  1429.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare una modalità di identificazione azione valida");

  1431.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1432.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1433.                     .getServizioIfErogazione(tipoServizio, nome, versione, env.idSoggetto.toIDSoggetto(), env),
  1434.                     "Accordo Servizio Parte Specifica");

  1436.             final IDPortaApplicativa idPorta = BaseHelper.supplyOrNotFound(
  1437.                     () -> env.paCore.getIDPortaApplicativaAssociataDefault(env.idServizioFactory.getIDServizioFromAccordo(asps)),
  1438.                     "Porta Applicativa Default");
  1439.             final PortaApplicativa pa = BaseHelper.supplyOrNotFound(() -> env.paCore.getPortaApplicativa(idPorta),
  1440.                     "Porta Applicativa Default");

  1442.             final PortaApplicativaAzione paa = pa.getAzione() == null ? new PortaApplicativaAzione() : pa.getAzione();

  1444.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  1445.             List<PortaApplicativaAzioneIdentificazione> identModes = env.paHelper.getModalitaIdentificazionePorta(
  1446.                     env.tipo_protocollo, env.apcCore.toMessageServiceBinding(apc.getServiceBinding()), 
  1447.                     ConsoleInterfaceType.AVANZATA); // uso avanzata per usare tutte le modalita

  1449.             if (identModes.contains(PortaApplicativaAzioneIdentificazione.PROTOCOL_BASED) && identModes.size() == 1) {
  1450.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  1451.                         "Non puoi modificare la url-invocazione il cui metodo di identificazione azioni può essere solo "
  1452.                                 + PortaApplicativaAzioneIdentificazione.PROTOCOL_BASED.toString());
  1453.             }
  1454.             if(!identModes.contains(PortaApplicativaAzioneIdentificazione.STATIC))
  1455.                 identModes.add(PortaApplicativaAzioneIdentificazione.STATIC); // gestisco sotto

  1457.             if (!identModes.contains(PortaApplicativaAzioneIdentificazione.valueOf(body.getModalita().name()))) {
  1458.                 throw FaultCode.RICHIESTA_NON_VALIDA
  1459.                 .toException("La modalità di identificazione azione deve essere una fra: " + identModes.toString());
  1460.             }

  1462.             boolean setPattern = true;
  1463.             long idAzione = -1;
  1464.             switch (body.getModalita()) {
  1465.             case CONTENT_BASED:
  1466.                 if(body.getPattern()==null) {
  1467.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1468.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'pattern'");
  1469.                 }
  1470.                 paa.setPattern(body.getPattern());
  1471.                 paa.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1472.                 break;
  1473.             case HEADER_BASED:
  1474.                 if(body.getNome()==null && body.getPattern()==null) {
  1475.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1476.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'nome'");
  1477.                 }
  1478.                 if(body.getNome()!=null && body.getPattern()!=null) {
  1479.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1480.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito solo il parametro 'nome'");
  1481.                 }
  1482.                 if(body.getNome()!=null) {
  1483.                     paa.setPattern(body.getNome());
  1484.                 }
  1485.                 else {
  1486.                     paa.setPattern(body.getPattern());
  1487.                 }
  1488.                 setPattern = true;
  1489.                 paa.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1490.                 break;
  1491.             case INPUT_BASED:
  1492.                 paa.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1493.                 break;
  1494.             case INTERFACE_BASED:
  1495.                 break;
  1496.             case SOAP_ACTION_BASED:
  1497.                 // permesso solo su API SOAP con 1 operazione
  1498.                 if(!ServiceBinding.SOAP.equals(apc.getServiceBinding())) {
  1499.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1500.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") non è permessa per API di tipo "+apc.getServiceBinding());
  1501.                 }
  1502.                 paa.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1503.                 break;
  1504.             case URL_BASED:
  1505.                 // permesso solo su API SOAP con 1 operazione
  1506.                 if(!ServiceBinding.SOAP.equals(apc.getServiceBinding())) {
  1507.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1508.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") non è permessa per API di tipo "+apc.getServiceBinding());
  1509.                 }
  1510.                 if(body.getPattern()==null) {
  1511.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1512.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'pattern'");
  1513.                 }
  1514.                 paa.setPattern(body.getPattern());
  1515.                 paa.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1516.                 break;
  1517.             case PROTOCOL_BASED:
  1518.                 break;
  1519.             case STATIC:
  1520.                 // permesso solo su API SOAP con 1 operazione
  1521.                 if(!ServiceBinding.SOAP.equals(apc.getServiceBinding())) {
  1522.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1523.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") non è permessa per API di tipo "+apc.getServiceBinding());
  1524.                 }
  1525.                 PortTypeSintetico pt = null;
  1526.                 for (PortTypeSintetico ptCheck : apc.getPortType()) {
  1527.                     if(ptCheck.getNome().equals(asps.getPortType())) {
  1528.                         pt = ptCheck;
  1529.                         break;
  1530.                     }
  1531.                 }
  1532.                 if(pt==null) {
  1533.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1534.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") è permessa solamente per API di tipo SOAP che definiscono 1 sola operazione: port-type non trovato");
  1535.                 }
  1536.                 if(pt.getAzione()==null || pt.getAzione().size()<=0) {
  1537.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1538.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") è permessa solamente per API di tipo SOAP che definiscono 1 sola operazione: non sono state trovate azioni");
  1539.                 }
  1540.                 if(pt.getAzione().size()>1) {
  1541.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1542.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") è permessa solamente per API di tipo SOAP che definiscono 1 sola operazione: sono state trovate "+pt.getAzione().size()+" azioni");
  1543.                 }
  1544.                 if(body.getNome()==null) {
  1545.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1546.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'nome'");
  1547.                 }
  1548.                 boolean findAzione = false;
  1549.                 for (OperationSintetica op : pt.getAzione()) {
  1550.                     if(op.getNome().equals(body.getNome())){
  1551.                         findAzione = true;
  1552.                         idAzione = op.getId();
  1553.                         break;
  1554.                     }
  1555.                 }
  1556.                 if(!findAzione) {
  1557.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1558.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") riferisce una azione '"+body.getNome()+"' non esistente");
  1559.                 }
  1560.                 paa.setNome(body.getNome());
  1561.                 setPattern = false;
  1562.                 break;
  1563.             }
  1564.             paa.setIdentificazione(Enum.valueOf(PortaApplicativaAzioneIdentificazione.class, body.getModalita().name()));

  1566.             String servizio = pa.getTipoSoggettoProprietario() + "/" + pa.getNomeSoggettoProprietario() + " "
  1567.                     + pa.getServizio().getTipo() + "/" + pa.getServizio().getNome() + "/"
  1568.                     + pa.getServizio().getVersione().intValue();

  1570.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID,
  1571.                     pa.getId().toString());
  1572.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_NOME_PORTA,
  1573.                     pa.getNome());
  1574.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO,
  1575.                     env.idSoggetto.getId().toString());
  1576.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SOGGETTO_VIRTUALE, "-"); // Come
  1577.             // da
  1578.             // debug.
  1579.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_SERVIZIO, servizio);
  1580.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_AZIONE,
  1581.                     setPattern ? paa.getPattern() : paa.getNome()); // Azione è il contenuto del campo pattern o del campo nome, che vengono settati
  1582.             // nel campo pattern.
  1583.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_AZIONE_ID, null); // Come
  1584.             // da
  1585.             // debug
  1586.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_MODE_AZIONE,
  1587.                     paa.getIdentificazione().toString());
  1588.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_XSD, null);
  1589.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_BEHAVIOUR, "");
  1590.             env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_INTEGRAZIONE, "");

  1592.             if(idAzione>0) {
  1593.                 env.requestWrapper.overrideParameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_AZIONE_ID, idAzione+"");
  1594.             }

  1596.             final String oldNomePA = pa.getNome();
  1597.             org.openspcoop2.message.constants.ServiceBinding serviceBinding = org.openspcoop2.message.constants.ServiceBinding.valueOf(apc.getServiceBinding().name());
  1598.             if (!env.paHelper.porteAppCheckData(TipoOperazione.CHANGE, oldNomePA, env.isSupportatoAutenticazioneSoggetti, false,
  1599.                     serviceBinding)) {
  1600.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  1601.             }

  1603.             pa.setOldIDPortaApplicativaForUpdate(idPorta);
  1604.             pa.setAzione(paa);

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

  1608.             context.getLogger().info("Invocazione completata con successo");

  1610.         } catch (javax.ws.rs.WebApplicationException e) {
  1611.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1612.             throw e;
  1613.         } catch (Throwable e) {
  1614.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1615.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1616.         }
  1617.     }

  1619. }
Created with JaCoCo 0.8.8.202204050719