FruizioniApiServiceImpl.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.  */

  21. package org.openspcoop2.core.config.rs.server.api.impl.fruizioni;

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

  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.PortaDelegata;
  33. import org.openspcoop2.core.config.PortaDelegataAzione;
  34. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  35. import org.openspcoop2.core.config.rs.server.api.FruizioniApi;
  36. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  37. import org.openspcoop2.core.config.rs.server.api.impl.IdServizio;
  38. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ConnettoreAPIHelper;
  39. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniApiHelper;
  40. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ErogazioniEnv;
  41. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ModiErogazioniApiHelper;
  42. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  43. import org.openspcoop2.core.config.rs.server.model.ApiDescrizione;
  44. import org.openspcoop2.core.config.rs.server.model.ApiImplAllegato;
  45. import org.openspcoop2.core.config.rs.server.model.ApiImplInformazioniGenerali;
  46. import org.openspcoop2.core.config.rs.server.model.ApiImplInformazioniGeneraliView;
  47. import org.openspcoop2.core.config.rs.server.model.ApiImplUrlInvocazione;
  48. import org.openspcoop2.core.config.rs.server.model.ApiImplUrlInvocazioneView;
  49. import org.openspcoop2.core.config.rs.server.model.ApiImplVersioneApi;
  50. import org.openspcoop2.core.config.rs.server.model.ApiImplVersioneApiView;
  51. import org.openspcoop2.core.config.rs.server.model.ConnettoreApplicativoServer;
  52. import org.openspcoop2.core.config.rs.server.model.ConnettoreFruizione;
  53. import org.openspcoop2.core.config.rs.server.model.ConnettoreMessageBox;
  54. import org.openspcoop2.core.config.rs.server.model.Fruizione;
  55. import org.openspcoop2.core.config.rs.server.model.FruizioneModI;
  56. import org.openspcoop2.core.config.rs.server.model.FruizioneViewItem;
  57. import org.openspcoop2.core.config.rs.server.model.ListaApiImplAllegati;
  58. import org.openspcoop2.core.config.rs.server.model.ListaFruizioni;
  59. import org.openspcoop2.core.config.rs.server.model.ModalitaIdentificazioneAzioneEnum;
  60. import org.openspcoop2.core.config.rs.server.model.TipoApiEnum;
  61. import org.openspcoop2.core.config.utils.UpdateProprietaOggetto;
  62. import org.openspcoop2.core.constants.TipiConnettore;
  63. import org.openspcoop2.core.id.IDFruizione;
  64. import org.openspcoop2.core.id.IDPortaDelegata;
  65. import org.openspcoop2.core.id.IDServizio;
  66. import org.openspcoop2.core.id.IDSoggetto;
  67. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  68. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  69. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  70. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  71. import org.openspcoop2.core.registry.Connettore;
  72. import org.openspcoop2.core.registry.Documento;
  73. import org.openspcoop2.core.registry.Fruitore;
  74. import org.openspcoop2.core.registry.IdSoggetto;
  75. import org.openspcoop2.core.registry.Soggetto;
  76. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  77. import org.openspcoop2.core.registry.beans.OperationSintetica;
  78. import org.openspcoop2.core.registry.beans.PortTypeSintetico;
  79. import org.openspcoop2.core.registry.constants.ServiceBinding;
  80. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  81. import org.openspcoop2.protocol.information_missing.constants.StatoType;
  82. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  83. import org.openspcoop2.protocol.sdk.constants.ConsoleInterfaceType;
  84. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  85. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  86. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  87. import org.openspcoop2.utils.service.BaseImpl;
  88. import org.openspcoop2.utils.service.authorization.AuthorizationConfig;
  89. import org.openspcoop2.utils.service.authorization.AuthorizationManager;
  90. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  91. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  92. import org.openspcoop2.utils.service.beans.utils.ListaUtils;
  93. import org.openspcoop2.utils.service.context.IContext;
  94. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  95. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  96. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  97. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaUtilities;
  98. import org.openspcoop2.web.lib.mvc.ServletUtils;
  99. import org.openspcoop2.web.lib.mvc.TipoOperazione;

  101. /**
  102.  * FruizioniApiServiceImpl
  103.  * 
  104.  * @author $Author$
  105.  * @version $Rev$, $Date$
  106.  * 
  107.  */
  108. public class FruizioniApiServiceImpl extends BaseImpl implements FruizioniApi {

  110.     public FruizioniApiServiceImpl() {
  111.         super(org.slf4j.LoggerFactory.getLogger(FruizioniApiServiceImpl.class));
  112.     }

  114.     private AuthorizationConfig getAuthorizationConfig() throws Exception {
  115.         return new AuthorizationConfig(ServerProperties.getInstance().getProperties());
  116.     }
  117.     
  118.     private javax.ws.rs.WebApplicationException newNotFoundSoggettoFruitore(ErogazioniEnv env){
  119.         return FaultCode.NOT_FOUND
  120.                 .toException("Soggetto fruitore " + env.idSoggetto.toString() + "non registrato per la fruizione scelta");
  121.     }

  123.     /**
  124.      * Creazione di una fruizione di API
  125.      *
  126.      * Questa operazione consente di creare una fruizione di API
  127.      *
  128.      */
  129.     @Override
  130.     public void createFruizione(Fruizione body, ProfiloEnum profilo, String soggetto) {
  131.         IContext context = this.getContext();
  132.         try {
  133.             context.getLogger().info("Invocazione in corso ...");

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

  138.             BaseHelper.throwIfNull(body);

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

  142.             final IdSoggetto idero = new IdSoggetto(new IDSoggetto(env.tipo_soggetto, body.getErogatore()));
  143.             final Soggetto erogatore = BaseHelper
  144.                     .supplyOrNotFound(() -> env.soggettiCore.getSoggettoRegistro(idero.toIDSoggetto()), "Soggetto Erogatore");
  145.             idero.setId(erogatore.getId());
  146.             final Soggetto fruitore = env.soggettiCore.getSoggettoRegistro(env.idSoggetto.toIDSoggetto());

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

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

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

  187.             if (alreadyExists)
  188.                 asps = env.apsCore.getServizio(idAps);

  190.             
  191.             ServletUtils.setObjectIntoSession(context.getServletRequest(), context.getServletRequest().getSession(),
  192.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE,
  193.                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  194.             ErogazioniApiHelper.serviziCheckData(TipoOperazione.ADD, env, as, asps, Optional.of(env.idSoggetto), body);

  196.             IDFruizione idFruizione = new IDFruizione();
  197.             
  198.             
  199.             idFruizione.setIdServizio(idAps);
  200.             idFruizione.setIdFruitore(new IDSoggetto(env.idSoggetto.getTipo(), env.idSoggetto.getNome()));

  202.             org.openspcoop2.core.registry.Connettore regConnettore = ErogazioniApiHelper.buildConnettoreRegistro(env,
  203.                     body.getConnettore());

  205.             Fruitore f = new Fruitore();
  206.             f.setTipo(fruitore.getTipo());
  207.             f.setNome(fruitore.getNome());
  208.             f.setStatoPackage(StatoType.FINALE.getValue());
  209.             f.setConnettore(regConnettore);
  210.             f.setDescrizione(body.getDescrizione());
  211.             env.apsCore.setDataCreazioneFruitore(f);
  212.             asps.addFruitore(f);

  214.             ProtocolProperties protocolProperties = null;
  215.             if(profilo != null) {
  216.                 
  217.                 boolean required = false;
  218.                 if(env.isProfiloModi()) {
  219.                     AccordoServizioParteComune accordoFull = Helper.getAccordoFull(body.getApiNome(),
  220.                             body.getApiVersione(), idReferente, env.apcCore);
  221.                     if(accordoFull.sizeProtocolPropertyList()>0) {
  222.                         for (org.openspcoop2.core.registry.ProtocolProperty pp : accordoFull.getProtocolPropertyList()) {
  223.                             if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO.equals(pp.getName())) {
  224.                                 String v = pp.getValue();
  225.                                 if(v!=null && StringUtils.isNotEmpty(v) && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_UNDEFINED.equals(v)) {
  226.                                     required = true;
  227.                                 }
  228.                             }
  229.                         }
  230.                     }
  231.                 }
  232.                 
  233.                 if(env.isProfiloModi()) {
  234.                     ErogazioniApiHelper.addInfoTokenPolicyForModI(regConnettore, env, true);
  235.                 }
  236.                 
  237.                 protocolProperties = ErogazioniApiHelper.getProtocolProperties(body, profilo, asps, env, required);
  238.     
  239.                 if(protocolProperties != null) {
  240.                     f.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  241.                 }
  242.             }


  245.             ErogazioniApiHelper.validateProperties(env, protocolProperties, idFruizione, ConsoleOperationType.ADD);

  247.             ErogazioniApiHelper.createAps(env, asps, regConnettore, body, alreadyExists, false);

  249.             context.getLogger().info("Invocazione completata con successo");
  250.             
  251.             // Bug Fix: altrimenti viene generato 204
  252.             context.getServletResponse().setStatus(201);
  253.             
  254.         } catch (javax.ws.rs.WebApplicationException e) {
  255.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  256.             throw e;
  257.         } catch (Throwable e) {
  258.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  259.             throw FaultCode.ERRORE_INTERNO.toException(e);
  260.         }
  261.     }

  263.     /**
  264.      * Creazione di un allegato nella fruizione di API
  265.      *
  266.      * Questa operazione consente di aggiungere un allegato alla fruizione di API
  267.      * identificata dall'erogatore, dal nome e dalla versione
  268.      *
  269.      */
  270.     @Override
  271.     public void createFruizioneAllegato(ApiImplAllegato body, String erogatore, String nome, Integer versione,
  272.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  273.         IContext context = this.getContext();
  274.         try {
  275.             context.getLogger().info("Invocazione in corso ...");

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

  280.             BaseHelper.throwIfNull(body);

  282.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  283.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  284.             AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  285.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  286.                     "Fruizione");
  287.             
  288.             final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);

  290.             try {
  291.                 env.pdCore.getIDPorteDelegateAssociate(idServizio, env.idSoggetto.toIDSoggetto());
  292.             } catch (Exception e) {
  293.                 throw FaultCode.NOT_FOUND.toException(e.getMessage());
  294.             }
  295.             
  296.             ErogazioniApiHelper.createAllegatoAsps(body, env, asps);

  298.             context.getLogger().info("Invocazione completata con successo");
  299.             
  300.             // Bug Fix: altrimenti viene generato 204
  301.             context.getServletResponse().setStatus(201);

  303.         } catch (javax.ws.rs.WebApplicationException e) {
  304.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  305.             throw e;
  306.         } catch (Throwable e) {
  307.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  308.             throw FaultCode.ERRORE_INTERNO.toException(e);
  309.         }
  310.     }

  312.     /**
  313.      * Elimina una fruizione di api
  314.      *
  315.      * Questa operazione consente di eliminare una fruizione di API identificata
  316.      * dall'erogatore, dal nome e dalla versione
  317.      *
  318.      */
  319.     @Override
  320.     public void deleteFruizione(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  321.             String tipoServizio) {
  322.         IContext context = this.getContext();
  323.         try {
  324.             context.getLogger().info("Invocazione in corso ...");

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

  329.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  330.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  331.             final AccordoServizioParteSpecifica asps = BaseHelper.evalnull(() -> ErogazioniApiHelper
  332.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env));

  334.             if (asps != null) {
  335.                 final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  336.                 final StringBuilder inUsoMessage = new StringBuilder();

  338.                 AccordiServizioParteSpecificaUtilities.deleteAccordoServizioParteSpecifica(asps, true, // gestioneFruitori,
  339.                         false, // gestioneErogatori,
  340.                         env.idSoggetto.toIDSoggetto(), idServizio, env.paCore.getExtendedServletPortaApplicativa(), env.userLogin,
  341.                         env.apsCore, env.apsHelper, inUsoMessage, "\n");

  343.                 if (inUsoMessage.length() > 0) {
  344.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(inUsoMessage.toString());
  345.                 }
  346.             } else if (env.delete_404) {
  347.                 throw FaultCode.NOT_FOUND.toException("Fruizione inesistente");
  348.             }

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

  352.         } catch (javax.ws.rs.WebApplicationException e) {
  353.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  354.             throw e;
  355.         } catch (Throwable e) {
  356.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  357.             throw FaultCode.ERRORE_INTERNO.toException(e);
  358.         }
  359.     }

  361.     /**
  362.      * Elimina un allegato dalla fruizione
  363.      *
  364.      * Questa operazione consente di eliminare un'allegato dalla fruizione di API
  365.      * identificata dall'erogatore, dal nome e dalla versione
  366.      *
  367.      */
  368.     @Override
  369.     public void deleteFruizioneAllegato(String erogatore, String nome, Integer versione, String nomeAllegato,
  370.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  371.         IContext context = this.getContext();
  372.         try {
  373.             context.getLogger().info("Invocazione in corso ...");

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

  378.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  379.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  380.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  381.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  382.                     "Fruizione");
  383.             
  384.             ErogazioniApiHelper.deleteAllegato(nomeAllegato, env, asps);

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

  388.         } catch (javax.ws.rs.WebApplicationException e) {
  389.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  390.             throw e;
  391.         } catch (Throwable e) {
  392.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  393.             throw FaultCode.ERRORE_INTERNO.toException(e);
  394.         }
  395.     }

  397.     /**
  398.      * Restituisce l'allegato di una fruizione
  399.      *
  400.      * Questa operazione consente di ottenere l'allegato di un'erogazione di API
  401.      * identificata dall'erogatore, dal nome e dalla versione
  402.      *
  403.      */
  404.     @Override
  405.     public byte[] downloadFruizioneAllegato(String erogatore, String nome, Integer versione, String nomeAllegato,
  406.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  407.         IContext context = this.getContext();
  408.         try {
  409.             context.getLogger().info("Invocazione in corso ...");

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

  414.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  415.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  416.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  417.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  418.                     "Fruizione");

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

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

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

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

  429.             Helper.setContentType(context, allegato.getFile());
  430.             
  431.             return allegato.getByteContenuto();
  432.         } catch (javax.ws.rs.WebApplicationException e) {
  433.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  434.             throw e;
  435.         } catch (Throwable e) {
  436.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  437.             throw FaultCode.ERRORE_INTERNO.toException(e);
  438.         }
  439.     }

  441.     /**
  442.      * Ricerca fruizioni di api
  443.      *
  444.      * Elenca le fruizioni di API
  445.      *
  446.      */
  447.     @Override
  448.     public ListaFruizioni findAllFruizioni(ProfiloEnum profilo, String soggetto, String q, Integer limit, Integer offset,
  449.             TipoApiEnum tipoApi, String tag, String uriApiImplementata, Boolean profiloQualsiasi, Boolean soggettoQualsiasi) {
  450.         IContext context = this.getContext();
  451.         try {
  452.             context.getLogger().info("Invocazione in corso ...");

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

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

  459.             final int idLista = Liste.SERVIZI;
  460.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  461.                     env.tipo_protocollo);

  463.             if(profiloQualsiasi!=null && profiloQualsiasi) {
  464.                 ricerca.clearFilter(idLista, Filtri.FILTRO_PROTOCOLLO);
  465.             }
  466.             if(soggettoQualsiasi!=null && soggettoQualsiasi) {
  467.                 ricerca.clearFilter(idLista, Filtri.FILTRO_SOGGETTO);
  468.             }
  469.             
  470.             if (tipoApi != null)
  471.                 ricerca.addFilter(idLista, Filtri.FILTRO_SERVICE_BINDING, tipoApi.toString().toLowerCase());

  473.             if(tag!=null) {
  474.                 ricerca.addFilter(idLista, Filtri.FILTRO_GRUPPO, tag);
  475.             }
  476.             
  477.             if(uriApiImplementata!=null) {
  478.                 ErogazioniApiHelper.setFiltroApiImplementata(uriApiImplementata, idLista, ricerca, env);
  479.             }
  480.             
  481.             List<AccordoServizioParteSpecifica> lista = env.apsCore.soggettiServizioList(null, ricerca, null, true, false);

  483.             if (env.findall_404 && lista.isEmpty()) {
  484.                 throw FaultCode.NOT_FOUND.toException("Nessuna fruizione presente nel registro");
  485.             }

  487.             final ListaFruizioni ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  488.                     ricerca.getIndexIniziale(idLista),
  489.                     ricerca.getPageSize(idLista), 
  490.                     ricerca.getNumEntries(idLista), ListaFruizioni.class);

  492.             // Prendo le fruizioni una ad una dagli asps
  493.             lista.forEach(asps -> {
  494.                 asps.getFruitoreList().forEach(fruitore -> {

  496.                     try {
  497.                         IdSoggetto idFruitore;
  498.                         idFruitore = new IdSoggetto(env.soggettiCore.getIdSoggettoRegistro(fruitore.getIdSoggetto()));
  499.                         idFruitore.setId(fruitore.getIdSoggetto());
  500.                         ret.addItemsItem(ErogazioniApiHelper
  501.                                 .fruizioneViewItemToFruizioneItem(ErogazioniApiHelper.aspsToFruizioneViewItem(env, asps, idFruitore)));

  503.                     } catch (Exception e) {
  504.                         // Cosa fare in questi casi? Errore interno perchè il fruitore deve essere
  505.                         // necessariamente presente
  506.                         // dato che l'erogazione l'abbiamo appena presa dal db?
  507.                         // Però altri utenti avrebbero potuto contemporaneamente modificare il db e
  508.                         // l'assenza del fruitore potrebbe essere perchè esso è stato appena eliminato.
  509.                         // Questa osservazione vale in generale.
  510.                         throw new RuntimeException(e);
  511.                     }
  512.                 });

  514.             });

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

  518.             return ret;

  520.         } catch (javax.ws.rs.WebApplicationException e) {
  521.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  522.             throw e;
  523.         } catch (Throwable e) {
  524.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  525.             throw FaultCode.ERRORE_INTERNO.toException(e);
  526.         }
  527.     }

  529.     /**
  530.      * Elenco allegati di una fruizione di API
  531.      *
  532.      * Questa operazione consente di ottenere gli allegati di una fruizione di API
  533.      * identificata dall'erogatore, dal nome e dalla versione
  534.      *
  535.      */
  536.     @Override
  537.     public ListaApiImplAllegati findAllFruizioneAllegati(String erogatore, String nome, Integer versione,
  538.             ProfiloEnum profilo, String soggetto, String tipoServizio, String q, Integer limit, Integer offset) {
  539.         IContext context = this.getContext();
  540.         try {
  541.             context.getLogger().info("Invocazione in corso ...");

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

  546.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  547.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  548.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  549.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  550.                     "Fruizione");

  552.             ListaApiImplAllegati ret = ErogazioniApiHelper.findAllAllegati(q, limit, offset,
  553.                     context.getUriInfo(), env, asps);

  555.             context.getLogger().info("Invocazione completata con successo");
  556.             return ret;
  557.         } catch (javax.ws.rs.WebApplicationException e) {
  558.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  559.             throw e;
  560.         } catch (Throwable e) {
  561.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  562.             throw FaultCode.ERRORE_INTERNO.toException(e);
  563.         }
  564.     }

  566.     /**
  567.      * Restituisce i dettagli di una fruizione di API
  568.      *
  569.      * Questa operazione consente di ottenere i dettagli di una fruizione di API
  570.      * identificata dall'erogatore, dal nome e dalla versione
  571.      *
  572.      */
  573.     @Override
  574.     public FruizioneViewItem getFruizione(String erogatore, String nome, Integer versione, ProfiloEnum profilo,
  575.             String soggetto, String tipoServizio) {
  576.         IContext context = this.getContext();
  577.         try {
  578.             context.getLogger().info("Invocazione in corso ...");

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

  583.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  584.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  585.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  586.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  587.                     "Fruizione");

  589.             FruizioneViewItem ret = ErogazioniApiHelper.aspsToFruizioneViewItem(env, asps, env.idSoggetto);

  591.             context.getLogger().info("Invocazione completata con successo");
  592.             return ret;

  594.         } catch (javax.ws.rs.WebApplicationException e) {
  595.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  596.             throw e;
  597.         } catch (Throwable e) {
  598.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  599.             throw FaultCode.ERRORE_INTERNO.toException(e);
  600.         }
  601.     }

  603.     /**
  604.      * Restituisce le informazioni sull'API implementata dalla fruizione
  605.      *
  606.      * Questa operazione consente di ottenere le informazioni sull'API implementata
  607.      * dall'erogazione identificata dall'erogatore, dal nome e dalla versione
  608.      *
  609.      */
  610.     @Override
  611.     public ApiImplVersioneApiView getFruizioneAPI(String erogatore, String nome, Integer versione, ProfiloEnum profilo,
  612.             String soggetto, String tipoServizio) {
  613.         IContext context = this.getContext();
  614.         try {
  615.             context.getLogger().info("Invocazione in corso ...");

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

  620.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  621.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  622.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  623.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  624.                     "Fruizione");

  626.             ApiImplVersioneApiView ret = ErogazioniApiHelper.aspsToApiImplVersioneApiView(env, asps);

  628.             context.getLogger().info("Invocazione completata con successo");
  629.             return ret;

  631.         } catch (javax.ws.rs.WebApplicationException e) {
  632.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  633.             throw e;
  634.         } catch (Throwable e) {
  635.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  636.             throw FaultCode.ERRORE_INTERNO.toException(e);
  637.         }
  638.     }

  640.     /**
  641.      * Restituisce il dettaglio di un allegato della fruizione
  642.      *
  643.      * Questa operazione consente di ottenere il dettaglio di un allegato della
  644.      * fruizione di API identificata dall'erogatore, dal nome e dalla versione
  645.      *
  646.      */
  647.     @Override
  648.     public ApiImplAllegato getFruizioneAllegato(String erogatore, String nome, Integer versione, String nomeAllegato,
  649.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  650.         IContext context = this.getContext();
  651.         try {
  652.             context.getLogger().info("Invocazione in corso ...");

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

  657.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  658.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  659.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  660.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  661.                     "Accordo servizio parte specifica");

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

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

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

  670.             context.getLogger().info("Invocazione completata con successo");
  671.             return ErogazioniApiHelper.documentoToImplAllegato(doc);

  673.         } catch (javax.ws.rs.WebApplicationException e) {
  674.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  675.             throw e;
  676.         } catch (Throwable e) {
  677.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  678.             throw FaultCode.ERRORE_INTERNO.toException(e);
  679.         }
  680.     }

  682.     /**
  683.      * Restituisce le informazioni su connettore associato alla fruizione
  684.      *
  685.      * Questa operazione consente di ottenere le informazioni sul connettore
  686.      * associato alla fruizione identificata dall'erogatore, dal nome e dalla
  687.      * versione
  688.      *
  689.      */
  690.     @Override
  691.     public ConnettoreFruizione getFruizioneConnettore(String erogatore, String nome, Integer versione, ProfiloEnum profilo,
  692.             String soggetto, String tipoServizio, String gruppo) {
  693.         IContext context = this.getContext();
  694.         try {
  695.             context.getLogger().info("Invocazione in corso ...");

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

  700.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  701.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  702.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  703.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  704.                     "Fruizione");

  706.             
  707.             
  708.             org.openspcoop2.core.registry.Connettore regConn = null;
  709.             
  710.             if(gruppo != null) {
  711.                 
  712.                 IdServizio idAsps = new IdServizio(env.idServizioFactory.getIDServizioFromAccordo(asps), asps.getId());

  714.                 IDPortaDelegata idPd = BaseHelper.supplyOrNotFound( () -> ErogazioniApiHelper.getIDGruppoPD(gruppo, env.idSoggetto.toIDSoggetto(), idAsps, env.apsCore), "Gruppo per l'erogazione scelta");
  715.                 PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);
  716.                 MappingFruizionePortaDelegata mapping = env.pdCore.getMappingFruizionePortaDelegata(pd);
  717.                 
  718.                 if(!mapping.isDefault()) {
  719.                     List<String> listaAzioniPDAssociataMappingNonDefault = pd.getAzione().getAzioneDelegataList();
  720.                     String azioneConnettore =  null;
  721.                     if(listaAzioniPDAssociataMappingNonDefault!=null && listaAzioniPDAssociataMappingNonDefault.size()>0) {
  722.                         azioneConnettore = listaAzioniPDAssociataMappingNonDefault.get(0);
  723.                     }

  725.                     
  726.                     long idServizioFruitoreInt = env.apsCore
  727.                             .getServizioFruitore(IDServizioFactory.getInstance().getIDServizioFromAccordo(asps), env.idSoggetto.getId());
  728.                     final Fruitore servFru = env.apsCore.getServizioFruitore(idServizioFruitoreInt);

  730.                     if (servFru == null)
  731.                         throw newNotFoundSoggettoFruitore(env);

  733.                     // Prendo pero poi immagine del fruitore dall'asps
  734.                     final Fruitore fruitore = BaseHelper.findFirst(asps.getFruitoreList(),
  735.                             f -> f.getTipo().equals(servFru.getTipo()) && f.getNome().equals(servFru.getNome()))
  736.                             .orElseThrow(() -> FaultCode.RICHIESTA_NON_VALIDA.toException("Fruizione non presente nel registro."));
  737.                             

  739.                     if(azioneConnettore!=null && !"".equals(azioneConnettore)) {
  740.                         for (ConfigurazioneServizioAzione check : fruitore.getConfigurazioneAzioneList()) {
  741.                             if(check.getAzioneList().contains(azioneConnettore)) {
  742.                                 regConn = check.getConnettore();
  743.                             }
  744.                         }
  745.                     }
  746.                 }
  747.             }

  749.             if(regConn == null) {
  750.                    regConn = ErogazioniApiHelper.getConnettoreFruizione(asps,
  751.                            env.idSoggetto, env);
  752.             }
  753.            
  754.             ConnettoreFruizione c = ConnettoreAPIHelper.buildConnettoreFruizione(regConn);

  756.             context.getLogger().info("Invocazione completata con successo");
  757.             return c;

  759.         } catch (javax.ws.rs.WebApplicationException e) {
  760.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  761.             throw e;
  762.         } catch (Throwable e) {
  763.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  764.             throw FaultCode.ERRORE_INTERNO.toException(e);
  765.         }
  766.     }

  768.     /**
  769.      * Restituisce la descrizione di una fruizione
  770.      *
  771.      * Questa operazione consente di ottenere la descrizione di una fruizione identificata dall&#x27;erogatore, dal nome e dalla versione
  772.      *
  773.      */
  774.     @Override
  775.     public ApiDescrizione getFruizioneDescrizione(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  776.         IContext context = this.getContext();
  777.         try {
  778.             context.getLogger().info("Invocazione in corso ...");     

  780.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  781.             context.getLogger().debug("Autorizzazione completata con successo");     
  782.                         
  783.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  784.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  785.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  786.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  787.                     "Fruizione");

  789.             IDFruizione idFruizione = new IDFruizione();
  790.             IDServizio idAps = new IDServizio();

  792.             if(asps!=null) {
  793.                 idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  794.                 idAps.setPortType(asps.getPortType());
  795.             }

  797.             idFruizione.setIdServizio(idAps);
  798.             idFruizione.setIdFruitore(new IDSoggetto(env.idSoggetto.getTipo(), env.idSoggetto.getNome()));

  800.             
  801.             Fruitore f = ErogazioniApiHelper.getFruitore(asps, env.idSoggetto.getNome());        
  802.             
  803.             ApiDescrizione descr = new ApiDescrizione();
  804.             descr.setDescrizione(f.getDescrizione());           
  805.             
  806.             context.getLogger().info("Invocazione completata con successo");
  807.             return descr;
  808.      
  809.         }
  810.         catch(javax.ws.rs.WebApplicationException e) {
  811.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  812.             throw e;
  813.         }
  814.         catch(Throwable e) {
  815.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  816.             throw FaultCode.ERRORE_INTERNO.toException(e);
  817.         }
  818.     }

  820.     /**
  821.      * Restituisce le informazioni generali di una fruizione di API
  822.      *
  823.      * Questa operazione consente di ottenere le informazioni generali di una
  824.      * fruizione di API identificata dall'erogatore, dal nome e dalla versione
  825.      *
  826.      */
  827.     @Override
  828.     public ApiImplInformazioniGeneraliView getFruizioneInformazioniGenerali(String erogatore, String nome,
  829.             Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  830.         IContext context = this.getContext();
  831.         try {
  832.             context.getLogger().info("Invocazione in corso ...");

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

  837.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  838.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  839.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  840.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  841.                     "Fruizione");

  843.             ApiImplInformazioniGeneraliView ret = ErogazioniApiHelper.fruizioneToApiImplInformazioniGeneraliView(env, asps,
  844.                     env.idSoggetto);

  846.             context.getLogger().info("Invocazione completata con successo");
  847.             return ret;

  849.         } catch (javax.ws.rs.WebApplicationException e) {
  850.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  851.             throw e;
  852.         } catch (Throwable e) {
  853.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  854.             throw FaultCode.ERRORE_INTERNO.toException(e);
  855.         }
  856.     }

  858.     /**
  859.      * Restituisce le informazioni ModI associate alla fruizione
  860.      *
  861.      * Questa operazione consente di ottenere le informazioni ModI associate all&#x27;erogazione identificata dall&#x27;erogatore, dal nome e dalla versione
  862.      *
  863.      */
  864.     @Override
  865.     public FruizioneModI getFruizioneModI(String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  866.         IContext context = this.getContext();
  867.         try {
  868.             context.getLogger().info("Invocazione in corso ...");     

  870.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  871.             context.getLogger().debug("Autorizzazione completata con successo");     
  872.                         
  873.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  874.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  875.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  876.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  877.                     "Fruizione");

  879.             IDFruizione idFruizione = new IDFruizione();
  880.             IDServizio idAps = new IDServizio();

  882.             if(asps!=null) {
  883.                 idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  884.                 idAps.setPortType(asps.getPortType());
  885.             }

  887.             idFruizione.setIdServizio(idAps);
  888.             idFruizione.setIdFruitore(new IDSoggetto(env.idSoggetto.getTipo(), env.idSoggetto.getNome()));

  890.             
  891.             Fruitore f = ErogazioniApiHelper.getFruitore(asps, env.idSoggetto.getNome());
  892.             
  893.             if(env.isProfiloModi()) {
  894.                 ErogazioniApiHelper.addInfoTokenPolicyForModI(f.getConnettore(), env, false);
  895.             }
  896.             
  897.             FruizioneModI ret = ModiErogazioniApiHelper.getFruizioneModI(asps, env, profilo, ErogazioniApiHelper.getProtocolPropertiesMap(idFruizione, f, env));

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

  913.     /**
  914.      * Restituisce le informazioni sull'url di invocazione necessaria ad invocare la
  915.      * fruizione
  916.      *
  917.      * Questa operazione consente di ottenere le informazioni sull'url di
  918.      * invocazione necessaria ad invocare la fruizione identificata dall'erogatore,
  919.      * dal nome e dalla versione
  920.      *
  921.      */
  922.     @Override
  923.     public ApiImplUrlInvocazioneView getFruizioneUrlInvocazione(String erogatore, String nome, Integer versione,
  924.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  925.         IContext context = this.getContext();
  926.         try {
  927.             context.getLogger().info("Invocazione in corso ...");

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

  932.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  933.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  934.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  935.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  936.                     "Fruizione");
  937.             final AccordoServizioParteComuneSintetico aspc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  938.             final IDPortaDelegata idPorta = BaseHelper.supplyOrNotFound(() -> env.pdCore.getIDPortaDelegataAssociataDefault(
  939.                     env.idServizioFactory.getIDServizioFromAccordo(asps), env.idSoggetto.toIDSoggetto()), "Porta Delegata");
  940.             final PortaDelegata pd = BaseHelper.supplyOrNotFound(() -> env.pdCore.getPortaDelegata(idPorta),
  941.                     "Porta Delegata");
  942.             final PortaDelegataAzione pdAzione = pd.getAzione();

  944.             String urlInvocazione = ErogazioniApiHelper.getUrlInvocazioneFruizione(asps, env.idSoggetto.toIDSoggetto(), env);
  945.             ApiImplUrlInvocazioneView ret = new ApiImplUrlInvocazioneView();

  947.             Map<String, String> azioni = env.paCore.getAzioniConLabel(asps, aspc, false, true, new ArrayList<>());
  948.             ret.setAzioni(Arrays.asList(azioni.keySet().toArray(new String[azioni.size()])));
  949.             ret.setForceInterface(Helper.statoFunzionalitaConfToBool(pdAzione.getForceInterfaceBased()));
  950.             ret.setModalita(Enum.valueOf(ModalitaIdentificazioneAzioneEnum.class, pdAzione.getIdentificazione().name()));
  951.             switch (ret.getModalita()) {
  952.             case CONTENT_BASED:
  953.             case URL_BASED:
  954.                 ret.setPattern(pdAzione.getPattern());
  955.                 break;
  956.             case HEADER_BASED:
  957.                 ret.setNome(pdAzione.getPattern());
  958.                 break;
  959.             case INPUT_BASED:
  960.             case PROTOCOL_BASED:
  961.             case SOAP_ACTION_BASED:
  962.                 break;
  963.             case STATIC:
  964.             case INTERFACE_BASED:
  965.                 ret.setForceInterface(false);
  966.                 break;
  967.             }
  968.             ret.setUrlInvocazione(urlInvocazione);

  970.             context.getLogger().info("Invocazione completata con successo");
  971.             return ret;

  973.         } catch (javax.ws.rs.WebApplicationException e) {
  974.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  975.             throw e;
  976.         } catch (Throwable e) {
  977.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  978.             throw FaultCode.ERRORE_INTERNO.toException(e);
  979.         }
  980.     }

  982.     /**
  983.      * Consente di modificare la versione dell'API implementata dalla fruizione
  984.      *
  985.      * Questa operazione consente di aggiornare la versione dell'API implementata
  986.      * dall'erogazione identificata dall'erogatore, dal nome e dalla versione
  987.      *
  988.      */
  989.     @Override
  990.     public void updateFruizioneAPI(ApiImplVersioneApi body, String erogatore, String nome, Integer versione,
  991.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  992.         IContext context = this.getContext();
  993.         try {
  994.             context.getLogger().info("Invocazione in corso ...");

  996.             BaseHelper.throwIfNull(body);

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

  1001.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1002.             final IdSoggetto idErogatore = new IdSoggetto(new IDSoggetto(env.tipo_soggetto, erogatore));
  1003.             final Soggetto soggErogatore = BaseHelper.supplyOrNotFound(
  1004.                     () -> env.soggettiCore.getSoggettoRegistro(idErogatore.toIDSoggetto()), "Soggetto Erogatore");
  1005.             idErogatore.setId(soggErogatore.getId());

  1007.             final AccordoServizioParteSpecifica asps = BaseHelper
  1008.                     .supplyOrNotFound(() -> ErogazioniApiHelper.getServizioIfFruizione(tipoServizio, nome, versione,
  1009.                             idErogatore.toIDSoggetto(), env.idSoggetto.toIDSoggetto(), env), "Fruizione");
  1010.             final AccordoServizioParteComuneSintetico as = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());

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

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

  1018.             if (!newApc.isPresent()) {
  1019.                 throw FaultCode.RICHIESTA_NON_VALIDA
  1020.                         .toException("Nessuna api " + as.getNome() + " e versione " + body.getApiVersione() + " registrata");
  1021.             }

  1023.             asps.setAccordoServizioParteComune(env.idAccordoFactory.getUriFromAccordo(newApc.get()));
  1024.             asps.setIdAccordo(newApc.get().getId());

  1026.             asps.setOldIDServizioForUpdate(env.idServizioFactory.getIDServizioFromAccordo(asps));
  1027.             
  1028.             ErogazioniApiHelper.serviziUpdateCheckData(as, asps, false, env);
  1029.             
  1030.             List<Object> oggettiDaAggiornare = AccordiServizioParteSpecificaUtilities.getOggettiDaAggiornare(asps,
  1031.                     env.apsCore);

  1033.             env.apsCore.performUpdateOperation(env.userLogin, false, oggettiDaAggiornare.toArray());
  1034.             context.getLogger().info("Invocazione completata con successo");

  1036.         } catch (javax.ws.rs.WebApplicationException e) {
  1037.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1038.             throw e;
  1039.         } catch (Throwable e) {
  1040.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1041.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1042.         }
  1043.     }

  1045.     /**
  1046.      * Modifica i dati di un allegato della fruizione
  1047.      *
  1048.      * Questa operazione consente di aggiornare i dettagli di un allegato della
  1049.      * fruizione di API identificata dall'erogatore, dal nome e dalla versione
  1050.      *
  1051.      */
  1052.     @Override
  1053.     public void updateFruizioneAllegato(ApiImplAllegato body, String erogatore, String nome, Integer versione,
  1054.             String nomeAllegato, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1055.         IContext context = this.getContext();
  1056.         try {
  1057.             context.getLogger().info("Invocazione in corso ...");

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

  1062.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1063.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  1064.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1065.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1066.                     "Fruizione");
  1067.             
  1068.             ErogazioniApiHelper.updateAllegatoAsps(body, nomeAllegato, env, asps);

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

  1072.         } catch (javax.ws.rs.WebApplicationException e) {
  1073.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1074.             throw e;
  1075.         } catch (Throwable e) {
  1076.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1077.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1078.         }
  1079.     }

  1081.     /**
  1082.      * Consente di modificare la configurazione del connettore associato alla
  1083.      * fruizione
  1084.      *
  1085.      * Questa operazione consente di aggiornare la configurazione del connettore
  1086.      * associato alla fruizione identificata dall'erogatore, dal nome e dalla
  1087.      * versione
  1088.      *
  1089.      */
  1090.     @Override
  1091.     public void updateFruizioneConnettore(ConnettoreFruizione body, String erogatore, String nome, Integer versione,
  1092.             ProfiloEnum profilo, String soggetto, String tipoServizio, String gruppo) {
  1093.         IContext context = this.getContext();
  1094.         try {
  1095.             context.getLogger().info("Invocazione in corso ...");

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

  1100.             BaseHelper.throwIfNull(body);

  1102.             if(body.getConnettore() instanceof ConnettoreMessageBox) {
  1103.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Impossibile associare a una fruizione il connettore di tipo message-box");
  1104.             }
  1105.             if(body.getConnettore() instanceof ConnettoreApplicativoServer) {
  1106.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Impossibile associare a una fruizione il connettore di tipo applicativo server");
  1107.             }
  1108.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1109.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);

  1111.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1112.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1113.                     "Fruizione");

  1115.             final List<Fruitore> fruitori = asps.getFruitoreList();

  1117.             long idServizioFruitoreInt = env.apsCore
  1118.                     .getServizioFruitore(IDServizioFactory.getInstance().getIDServizioFromAccordo(asps), env.idSoggetto.getId());
  1119.             final Fruitore servFru = env.apsCore.getServizioFruitore(idServizioFruitoreInt);

  1121.             if (servFru == null)
  1122.                 throw newNotFoundSoggettoFruitore(env);

  1124.             org.openspcoop2.core.registry.Connettore connettore = null;

  1126.             IDPortaDelegata idPd = null;
  1127.             
  1128.             // Prendo pero poi immagine del fruitore dall'asps
  1129.             final Fruitore fruitore = BaseHelper.findAndRemoveFirst(fruitori,
  1130.                     f -> f.getTipo().equals(servFru.getTipo()) && f.getNome().equals(servFru.getNome()));


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

  1135.             if(gruppo != null) {
  1136.                 idPd = BaseHelper.supplyOrNonValida( () -> ErogazioniApiHelper.getIDGruppoPD(gruppo, env.idSoggetto.toIDSoggetto(), idAsps, env.apsCore), "Gruppo per l'erogazione scelta");
  1137.                 PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);
  1138.                 MappingFruizionePortaDelegata mapping = env.pdCore.getMappingFruizionePortaDelegata(pd);
  1139.                 
  1140.                 if(!mapping.isDefault()) {
  1141.                     List<String> listaAzioniPDAssociataMappingNonDefault = pd.getAzione().getAzioneDelegataList();
  1142.                     String azioneConnettore =  null;
  1143.                     if(listaAzioniPDAssociataMappingNonDefault!=null && listaAzioniPDAssociataMappingNonDefault.size()>0) {
  1144.                         azioneConnettore = listaAzioniPDAssociataMappingNonDefault.get(0);
  1145.                     }

  1147.                     if(azioneConnettore!=null && !"".equals(azioneConnettore)) {
  1148.                         for (ConfigurazioneServizioAzione check : fruitore.getConfigurazioneAzioneList()) {
  1149.                             if(check.getAzioneList().contains(azioneConnettore)) {
  1150.                                 connettore = check.getConnettore();
  1151.                             }
  1152.                         }
  1153.                     }
  1154.                 }

  1156.             } else {
  1157.                 idPd = env.pdCore.getIDPortaDelegataAssociataDefault(idAsps, env.idSoggetto.toIDSoggetto());
  1158.             }

  1160.             PortaDelegata pd = env.pdCore.getPortaDelegata(idPd);


  1163.             if(gruppo != null) {
  1164.                 if(connettore != null) {
  1165.                     String oldConnT = connettore.getTipo();
  1166.                     if ((connettore.getCustom() != null && connettore.getCustom())
  1167.                             && !connettore.getTipo().equals(TipiConnettore.HTTPS.toString())
  1168.                             && !connettore.getTipo().equals(TipiConnettore.FILE.toString())
  1169.                             && !connettore.getTipo().equals(TipiConnettore.STATUS.toString())) {
  1170.                         oldConnT = TipiConnettore.CUSTOM.toString();
  1171.                     }

  1173.                     ConnettoreAPIHelper.fillConnettoreRegistro(connettore, env, body.getConnettore(), oldConnT);

  1175.                     if (!ConnettoreAPIHelper.connettoreCheckData(body.getConnettore(), env, false)) {
  1176.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  1177.                     }

  1179.                 } else {
  1180.     
  1181.                     ConfigurazioneServizioAzione configurazioneAzione = new ConfigurazioneServizioAzione();
  1182.                     Connettore connettoreN = new Connettore();
  1183.     
  1184.                     String oldConnT = connettoreN.getTipo();
  1185.                     if ((connettoreN.getCustom() != null && connettoreN.getCustom())
  1186.                             && !connettoreN.getTipo().equals(TipiConnettore.HTTPS.toString())
  1187.                             && !connettoreN.getTipo().equals(TipiConnettore.FILE.toString())
  1188.                             && !connettoreN.getTipo().equals(TipiConnettore.STATUS.toString())) {
  1189.                         oldConnT = TipiConnettore.CUSTOM.toString();
  1190.                     }
  1191.     
  1192.                     ConnettoreAPIHelper.fillConnettoreRegistro(connettoreN, env, body.getConnettore(), oldConnT);
  1193.     
  1194.                     if (!ConnettoreAPIHelper.connettoreCheckData(body.getConnettore(), env, false)) {
  1195.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  1196.                     }

  1198.                     configurazioneAzione.setConnettore(connettoreN);
  1199.                     for (int i = 0; i < pd.getAzione().sizeAzioneDelegataList(); i++) {
  1200.                         configurazioneAzione.addAzione(pd.getAzione().getAzioneDelegata(i));
  1201.                     }
  1202.                     fruitore.addConfigurazioneAzione(configurazioneAzione);
  1203.     
  1204.                 } 
  1205.             } else {
  1206.                 
  1207.                 connettore = fruitore.getConnettore();
  1208.                 
  1209.                 String oldConnT = connettore.getTipo();
  1210.                 if ((connettore.getCustom() != null && connettore.getCustom())
  1211.                         && !connettore.getTipo().equals(TipiConnettore.HTTPS.toString())
  1212.                         && !connettore.getTipo().equals(TipiConnettore.FILE.toString())
  1213.                         && !connettore.getTipo().equals(TipiConnettore.STATUS.toString())) {
  1214.                     oldConnT = TipiConnettore.CUSTOM.toString();
  1215.                 }

  1217.                 ConnettoreAPIHelper.fillConnettoreRegistro(connettore, env, body.getConnettore(), oldConnT);

  1219.                 if (!ConnettoreAPIHelper.connettoreCheckData(body.getConnettore(), env, false)) {
  1220.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  1221.                 }

  1223.                 fruitore.setConnettore(ConnettoreAPIHelper.buildConnettoreRegistro(env, body.getConnettore()));
  1224.             }
  1225.             
  1226.             fruitori.add(fruitore);
  1227.             env.apsCore.setDataAggiornamentoFruitore(fruitore);
  1228.             asps.setFruitoreList(fruitori);

  1230.             if(gruppo != null) {
  1231.                 IDPortaDelegata idPD = new IDPortaDelegata();
  1232.                 idPD.setNome(pd.getNome());
  1233.                 UpdateProprietaOggetto uPO = new UpdateProprietaOggetto(idPD, env.userLogin);
  1234.                 env.apsCore.performUpdateOperation(env.userLogin, false, asps, uPO);
  1235.             }
  1236.             else {
  1237.                 env.apsCore.performUpdateOperation(env.userLogin, false, asps);
  1238.             }

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

  1242.         } catch (javax.ws.rs.WebApplicationException e) {
  1243.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1244.             throw e;
  1245.         } catch (Throwable e) {
  1246.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1247.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1248.         }
  1249.     }

  1251.     /**
  1252.      * Consente di modificare la descrizione di una fruizione
  1253.      *
  1254.      * Questa operazione consente di aggiornare la descrizione di una erogazione identificata dall&#x27;erogatore, dal nome e dalla versione
  1255.      *
  1256.      */
  1257.     @Override
  1258.     public void updateFruizioneDescrizione(ApiDescrizione body, String erogatore, String nome, Integer versione, ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1259.         IContext context = this.getContext();
  1260.         try {
  1261.             context.getLogger().info("Invocazione in corso ...");     

  1263.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1264.             context.getLogger().debug("Autorizzazione completata con successo");     
  1265.                         
  1266.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1267.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  1268.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1269.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1270.                     "Fruizione");
  1271.             
  1272.             final IDServizio idAps = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(),
  1273.                     new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione());

  1275.             IDFruizione idFruizione = new IDFruizione();
  1276.             
  1277.             idFruizione.setIdServizio(idAps);
  1278.             idFruizione.setIdFruitore(new IDSoggetto(env.idSoggetto.getTipo(), env.idSoggetto.getNome()));

  1280.             long idServizioFruitoreInt = env.apsCore
  1281.                     .getServizioFruitore(IDServizioFactory.getInstance().getIDServizioFromAccordo(asps), env.idSoggetto.getId());
  1282.             final Fruitore servFru = env.apsCore.getServizioFruitore(idServizioFruitoreInt);

  1284.             if (servFru == null)
  1285.                 throw newNotFoundSoggettoFruitore(env);

  1287.             // Prendo pero poi immagine del fruitore dall'asps
  1288.             final Fruitore fruitore = BaseHelper.findFirst(asps.getFruitoreList(),
  1289.                     f -> f.getTipo().equals(servFru.getTipo()) && f.getNome().equals(servFru.getNome()))
  1290.                     .orElseThrow(() -> FaultCode.RICHIESTA_NON_VALIDA.toException("Fruizione non presente nel registro."));
  1291.             
  1292.             fruitore.setDescrizione(body.getDescrizione());
  1293.             
  1294.             env.apsCore.setDataAggiornamentoFruitore(fruitore);
  1295.             
  1296.             IDServizio oldIDServizioForUpdate = env.idServizioFactory.getIDServizioFromAccordo(asps);
  1297.             asps.setOldIDServizioForUpdate(oldIDServizioForUpdate);
  1298.             
  1299.             List<Object> oggettiDaAggiornare = AccordiServizioParteSpecificaUtilities.getOggettiDaAggiornare(asps,
  1300.                     env.apsCore);

  1302.             env.apsCore.performUpdateOperation(env.userLogin, false, oggettiDaAggiornare.toArray());
  1303.         
  1304.             context.getLogger().info("Invocazione completata con successo");
  1305.         
  1306.         }
  1307.         catch(javax.ws.rs.WebApplicationException e) {
  1308.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1309.             throw e;
  1310.         }
  1311.         catch(Throwable e) {
  1312.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1313.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1314.         }
  1315.     }

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

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

  1334.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1335.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  1336.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1337.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1338.                     "Fruizione");
  1339.             
  1340.             ErogazioniApiHelper.updateInformazioniGenerali(body, env, asps, false);

  1342.             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 alla fruizione
  1354.      *
  1355.      * Questa operazione consente di aggiornare le informazioni ModI associate all&#x27;erogazione identificata dall&#x27;erogatore, dal nome e dalla versione
  1356.      *
  1357.      */
  1358.     @Override
  1359.     public void updateFruizioneModI(FruizioneModI body, String erogatore, 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");     
  1366.                         
  1367.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1368.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  1369.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1370.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1371.                     "Fruizione");
  1372.             
  1373.             final IDServizio idAps = env.idServizioFactory.getIDServizioFromValues(asps.getTipo(), asps.getNome(),
  1374.                     new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore()), asps.getVersione());

  1376.             IDFruizione idFruizione = new IDFruizione();
  1377.             
  1378.             idFruizione.setIdServizio(idAps);
  1379.             idFruizione.setIdFruitore(new IDSoggetto(env.idSoggetto.getTipo(), env.idSoggetto.getNome()));


  1382.             ProtocolProperties protocolProperties = null;
  1383.             if(profilo != null) {
  1384.                 protocolProperties = ModiErogazioniApiHelper.updateModiProtocolProperties(asps, profilo, body.getModi(), env);
  1385.     
  1386.                 if(protocolProperties != null) {
  1387.                     Fruitore f = ErogazioniApiHelper.getFruitore(asps, env.idSoggetto.getNome());
  1388.                     f.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  1389.                 }
  1390.             }

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

  1394.             ErogazioniApiHelper.validateProperties(env, protocolProperties, idFruizione, ConsoleOperationType.CHANGE);

  1396.             long idServizioFruitoreInt = env.apsCore
  1397.                     .getServizioFruitore(IDServizioFactory.getInstance().getIDServizioFromAccordo(asps), env.idSoggetto.getId());
  1398.             final Fruitore servFru = env.apsCore.getServizioFruitore(idServizioFruitoreInt);

  1400.             if (servFru == null)
  1401.                 throw newNotFoundSoggettoFruitore(env);

  1403.             // Prendo pero poi immagine del fruitore dall'asps
  1404.             final Fruitore fruitore = BaseHelper.findFirst(asps.getFruitoreList(),
  1405.                     f -> f.getTipo().equals(servFru.getTipo()) && f.getNome().equals(servFru.getNome()))
  1406.                     .orElseThrow(() -> FaultCode.RICHIESTA_NON_VALIDA.toException("Fruizione non presente nel registro."));
  1407.             
  1408.             env.apsCore.setDataAggiornamentoFruitore(fruitore);
  1409.             
  1410.             List<Object> oggettiDaAggiornare = AccordiServizioParteSpecificaUtilities.getOggettiDaAggiornare(asps,
  1411.                     env.apsCore);

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

  1415.         
  1416.             context.getLogger().info("Invocazione completata con successo");
  1417.         }
  1418.         catch(javax.ws.rs.WebApplicationException e) {
  1419.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1420.             throw e;
  1421.         }
  1422.         catch(Throwable e) {
  1423.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1424.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1425.         }
  1426.     }

  1428.     /**
  1429.      * Consente di modificare la configurazione utilizzata per identificare l'azione
  1430.      * invocata dell'API implementata dalla fruizione
  1431.      *
  1432.      * Questa operazione consente di aggiornare la configurazione utilizzata dal
  1433.      * Gateway per identificare l'azione invocata
  1434.      *
  1435.      */
  1436.     @Override
  1437.     public void updateFruizioneUrlInvocazione(ApiImplUrlInvocazione body, String erogatore, String nome, Integer versione,
  1438.             ProfiloEnum profilo, String soggetto, String tipoServizio) {
  1439.         IContext context = this.getContext();
  1440.         try {
  1441.             context.getLogger().info("Invocazione in corso ...");

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

  1446.             BaseHelper.throwIfNull(body);

  1448.             if (body.getModalita() == null) {
  1449.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare una modalità di identificazione azione valida");
  1450.             }

  1452.             final ErogazioniEnv env = new ErogazioniEnv(context.getServletRequest(), profilo, soggetto, context);
  1453.             final IDSoggetto idErogatore = new IDSoggetto(env.tipo_soggetto, erogatore);
  1454.             final AccordoServizioParteSpecifica asps = BaseHelper.supplyOrNotFound(() -> ErogazioniApiHelper
  1455.                     .getServizioIfFruizione(tipoServizio, nome, versione, idErogatore, env.idSoggetto.toIDSoggetto(), env),
  1456.                     "Fruizione");
  1457.             final IDServizio idServizio = env.idServizioFactory.getIDServizioFromAccordo(asps);
  1458.             final IDPortaDelegata idPorta = BaseHelper.supplyOrNotFound(() -> env.pdCore.getIDPortaDelegataAssociataDefault(
  1459.                     env.idServizioFactory.getIDServizioFromAccordo(asps), env.idSoggetto.toIDSoggetto()), "Porta Delegata");
  1460.             final PortaDelegata pd = BaseHelper.supplyOrNotFound(() -> env.pdCore.getPortaDelegata(idPorta),
  1461.                     "Porta Delegata");
  1462.             final PortaDelegataAzione pdAzione = new PortaDelegataAzione(); // pd.getAzione() == null ? new
  1463.                                                                                                                                             // PortaDelegataAzione() : pd.getAzione();

  1465.             final AccordoServizioParteComuneSintetico apc = env.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());

  1467.             List<PortaDelegataAzioneIdentificazione> identModes = env.pdHelper.getModalitaIdentificazionePorta(
  1468.                     env.tipo_protocollo, env.apcCore.toMessageServiceBinding(apc.getServiceBinding()),
  1469.                     ConsoleInterfaceType.AVANZATA); // uso avanzata per usare tutte le modalita
  1470.             if(!identModes.contains(PortaDelegataAzioneIdentificazione.STATIC))
  1471.                 identModes.add(PortaDelegataAzioneIdentificazione.STATIC); // gestisco sotto
  1472.             
  1473.             if (!identModes.contains(PortaDelegataAzioneIdentificazione.valueOf(body.getModalita().name())))
  1474.                 throw FaultCode.RICHIESTA_NON_VALIDA
  1475.                         .toException("La modalità di identificazione azione deve essere una fra: " + identModes.toString());

  1477.             boolean setPattern = true;
  1478.             long idAzione = -1;
  1479.             switch (body.getModalita()) {
  1480.             case CONTENT_BASED:
  1481.                 if(body.getPattern()==null) {
  1482.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1483.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'pattern'");
  1484.                 }
  1485.                 pdAzione.setPattern(body.getPattern());
  1486.                 pdAzione.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1487.                 break;
  1488.             case HEADER_BASED:
  1489.                 if(body.getNome()==null && body.getPattern()==null) {
  1490.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1491.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'nome'");
  1492.                 }
  1493.                 if(body.getNome()!=null && body.getPattern()!=null) {
  1494.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1495.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito solo il parametro 'nome'");
  1496.                 }
  1497.                 if(body.getNome()!=null) {
  1498.                     pdAzione.setPattern(body.getNome());
  1499.                 }
  1500.                 else {
  1501.                     pdAzione.setPattern(body.getPattern());
  1502.                 }
  1503.                 setPattern = true;
  1504.                 pdAzione.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1505.                 break;
  1506.             case INPUT_BASED:
  1507.                 pdAzione.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1508.                 break;
  1509.             case INTERFACE_BASED:
  1510.                 break;
  1511.             case SOAP_ACTION_BASED:
  1512.                 // permesso solo su API SOAP con 1 operazione
  1513.                 if(!ServiceBinding.SOAP.equals(apc.getServiceBinding())) {
  1514.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1515.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") non è permessa per API di tipo "+apc.getServiceBinding());
  1516.                 }
  1517.                 pdAzione.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1518.                 break;
  1519.             case URL_BASED:
  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.                 if(body.getPattern()==null) {
  1526.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1527.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'pattern'");
  1528.                 }
  1529.                 pdAzione.setPattern(body.getPattern());
  1530.                 pdAzione.setForceInterfaceBased(Helper.boolToStatoFunzionalitaConf(body.isForceInterface()));
  1531.                 break;
  1532.             case PROTOCOL_BASED:
  1533.                 break;
  1534.             case STATIC:
  1535.                 // permesso solo su API SOAP con 1 operazione
  1536.                 if(!ServiceBinding.SOAP.equals(apc.getServiceBinding())) {
  1537.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1538.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") non è permessa per API di tipo "+apc.getServiceBinding());
  1539.                 }
  1540.                 PortTypeSintetico pt = null;
  1541.                 for (PortTypeSintetico ptCheck : apc.getPortType()) {
  1542.                     if(ptCheck.getNome().equals(asps.getPortType())) {
  1543.                         pt = ptCheck;
  1544.                         break;
  1545.                     }
  1546.                 }
  1547.                 if(pt==null) {
  1548.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1549.                         .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");
  1550.                 }
  1551.                 if(pt.getAzione()==null || pt.getAzione().size()<=0) {
  1552.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1553.                     .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");
  1554.                 }
  1555.                 if(pt.getAzione().size()>1) {
  1556.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1557.                     .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");
  1558.                 }
  1559.                 if(body.getNome()==null) {
  1560.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1561.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") richiede che sia definito il parametro 'nome'");
  1562.                 }
  1563.                 boolean findAzione = false;
  1564.                 for (OperationSintetica op : pt.getAzione()) {
  1565.                     if(op.getNome().equals(body.getNome())){
  1566.                         findAzione = true;
  1567.                         idAzione = op.getId();
  1568.                         break;
  1569.                     }
  1570.                 }
  1571.                 if(!findAzione) {
  1572.                     throw FaultCode.RICHIESTA_NON_VALIDA
  1573.                     .toException("La modalità di identificazione azione indicata ("+body.getModalita().toString()+") riferisce una azione '"+body.getNome()+"' non esistente");
  1574.                 }
  1575.                 pdAzione.setNome(body.getNome());
  1576.                 setPattern = false;
  1577.                 break;
  1578.             }

  1580.             pdAzione.setIdentificazione(Enum.valueOf(PortaDelegataAzioneIdentificazione.class, body.getModalita().name()));

  1582.             ErogazioniApiHelper.overrideFruizioneUrlInvocazione(env.requestWrapper, idErogatore, idServizio, pd, pdAzione, setPattern, idAzione);

  1584.             org.openspcoop2.message.constants.ServiceBinding serviceBinding = org.openspcoop2.message.constants.ServiceBinding.valueOf(apc.getServiceBinding().name());
  1585.             if (!env.pdHelper.porteDelegateCheckData(TipoOperazione.CHANGE, pd.getNome(), false,
  1586.                     serviceBinding)) {
  1587.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(env.pd.getMessage());
  1588.             }

  1590.             pd.setAzione(pdAzione);
  1591.             pd.setOldIDPortaDelegataForUpdate(idPorta);
  1592.                         
  1593.             env.pdCore.performUpdateOperation(env.userLogin, false, pd);

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

  1597.         } catch (javax.ws.rs.WebApplicationException e) {
  1598.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1599.             throw e;
  1600.         } catch (Throwable e) {
  1601.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1602.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1603.         }
  1604.     }

  1606. }
Created with JaCoCo 0.8.8.202204050719