ApiApiServiceImpl.java

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

  22. import java.util.ArrayList;
  23. import java.util.Arrays;
  24. import java.util.List;

  26. import org.apache.commons.lang.StringEscapeUtils;
  27. import org.apache.commons.lang.StringUtils;
  28. import org.openspcoop2.core.commons.Filtri;
  29. import org.openspcoop2.core.commons.Liste;
  30. import org.openspcoop2.core.config.rs.server.api.ApiApi;
  31. import org.openspcoop2.core.config.rs.server.api.impl.Enums;
  32. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  33. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  34. import org.openspcoop2.core.config.rs.server.model.Api;
  35. import org.openspcoop2.core.config.rs.server.model.ApiAllegato;
  36. import org.openspcoop2.core.config.rs.server.model.ApiAzione;
  37. import org.openspcoop2.core.config.rs.server.model.ApiCanale;
  38. import org.openspcoop2.core.config.rs.server.model.ApiDescrizione;
  39. import org.openspcoop2.core.config.rs.server.model.ApiInformazioniGenerali;
  40. import org.openspcoop2.core.config.rs.server.model.ApiInformazioniGeneraliView;
  41. import org.openspcoop2.core.config.rs.server.model.ApiInterfaccia;
  42. import org.openspcoop2.core.config.rs.server.model.ApiInterfacciaRest;
  43. import org.openspcoop2.core.config.rs.server.model.ApiInterfacciaSoap;
  44. import org.openspcoop2.core.config.rs.server.model.ApiInterfacciaView;
  45. import org.openspcoop2.core.config.rs.server.model.ApiItem;
  46. import org.openspcoop2.core.config.rs.server.model.ApiModI;
  47. import org.openspcoop2.core.config.rs.server.model.ApiReferenteView;
  48. import org.openspcoop2.core.config.rs.server.model.ApiRisorsa;
  49. import org.openspcoop2.core.config.rs.server.model.ApiServizio;
  50. import org.openspcoop2.core.config.rs.server.model.ApiTags;
  51. import org.openspcoop2.core.config.rs.server.model.ApiViewItem;
  52. import org.openspcoop2.core.config.rs.server.model.CanaleEnum;
  53. import org.openspcoop2.core.config.rs.server.model.ConfigurazioneApiCanale;
  54. import org.openspcoop2.core.config.rs.server.model.ConfigurazioneCanaleEnum;
  55. import org.openspcoop2.core.config.rs.server.model.HttpMethodEnum;
  56. import org.openspcoop2.core.config.rs.server.model.ListaApi;
  57. import org.openspcoop2.core.config.rs.server.model.ListaApiAllegati;
  58. import org.openspcoop2.core.config.rs.server.model.ListaApiAzioni;
  59. import org.openspcoop2.core.config.rs.server.model.ListaApiRisorse;
  60. import org.openspcoop2.core.config.rs.server.model.ListaApiServizi;
  61. import org.openspcoop2.core.config.rs.server.model.RuoloAllegatoAPI;
  62. import org.openspcoop2.core.config.rs.server.model.TipoApiEnum;
  63. import org.openspcoop2.core.id.IDAccordo;
  64. import org.openspcoop2.core.id.IDPortType;
  65. import org.openspcoop2.core.id.IDPortTypeAzione;
  66. import org.openspcoop2.core.id.IDResource;
  67. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  68. import org.openspcoop2.core.registry.Documento;
  69. import org.openspcoop2.core.registry.GruppiAccordo;
  70. import org.openspcoop2.core.registry.Gruppo;
  71. import org.openspcoop2.core.registry.GruppoAccordo;
  72. import org.openspcoop2.core.registry.Operation;
  73. import org.openspcoop2.core.registry.PortType;
  74. import org.openspcoop2.core.registry.Resource;
  75. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  76. import org.openspcoop2.core.registry.constants.HttpMethod;
  77. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  78. import org.openspcoop2.core.registry.constants.ServiceBinding;
  79. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  80. import org.openspcoop2.protocol.basic.Costanti;
  81. import org.openspcoop2.protocol.basic.archive.APIUtils;
  82. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  83. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  84. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  85. import org.openspcoop2.utils.json.YAMLUtils;
  86. import org.openspcoop2.utils.service.BaseImpl;
  87. import org.openspcoop2.utils.service.authorization.AuthorizationConfig;
  88. import org.openspcoop2.utils.service.authorization.AuthorizationManager;
  89. import org.openspcoop2.utils.service.beans.ProfiloCollaborazioneEnum;
  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.core.SerialiableFormFile;
  97. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  98. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneHelper;
  99. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneUtilities;
  100. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCore;
  101. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviHelper;
  102. import org.openspcoop2.web.ctrlstat.servlet.gruppi.GruppiCore;
  103. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  104. import org.openspcoop2.web.lib.mvc.TipoOperazione;

  106. /**
  107.  * ApiApiServiceImpl
  108.  * 
  109.  * @author $Author$
  110.  * @version $Rev$, $Date$
  111.  * 
  112.  */
  113. public class ApiApiServiceImpl extends BaseImpl implements ApiApi {

  115.     public ApiApiServiceImpl() {
  116.         super(org.slf4j.LoggerFactory.getLogger(ApiApiServiceImpl.class));
  117.     }

  119.     private AuthorizationConfig getAuthorizationConfig() throws Exception {
  120.         return new AuthorizationConfig(ServerProperties.getInstance().getProperties());
  121.     }

  123.     /**
  124.      * Creazione di un'API
  125.      *
  126.      * Questa operazione consente di creare una API
  127.      *
  128.      */
  129.     @Override
  130.     public void createApi(Api 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.             if (body == null)
  139.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  141.             if (body.getReferente() == null || "".equals(body.getReferente().trim())) {
  142.                 body.setReferente(soggetto);
  143.             }

  145.             ApiEnv env = new ApiEnv(profilo, soggetto, context);

  147.             AccordoServizioParteComune as = ApiApiHelper.accordoApiToRegistro(body, env);

  149.             ProtocolProperties protocolProperties = null;
  150.             if(profilo != null) {
  151.                 protocolProperties = ApiApiHelper.getProtocolProperties(body, profilo);
  152.     
  153.                 if(protocolProperties != null) {
  154.                     as.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  155.                 }
  156.             }
  157.             
  158.             IDAccordo idAccordoFromAccordo = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  159.             if (env.apcCore.existsAccordoServizio(idAccordoFromAccordo))
  160.                 throw FaultCode.CONFLITTO.toException("Api già esistente");

  162.             boolean validazioneDocumenti = ServerProperties.getInstance().isValidazioneDocumenti();

  164.             StringBuilder bfTags = new StringBuilder();
  165.             if(body!=null && body.getTags()!=null && !body.getTags().isEmpty()) {
  166.                 for (String tag : body.getTags()) {
  167.                     if(bfTags.length()>0) {
  168.                         bfTags.append(",");
  169.                     }
  170.                     bfTags.append(tag);
  171.                 }
  172.             }
  173.             
  174.             boolean gestioneCanaliEnabled = env.gestioneCanali;
  175.             String canale = as.getCanale();
  176.             String canaleStato = null;
  177.             if(canale == null) {
  178.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  179.             } else {
  180.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  181.             }
  182.                         
  183.             if (!env.apcHelper.accordiCheckData(TipoOperazione.ADD, as.getNome(), as.getDescrizione(),
  184.                     as.getProfiloCollaborazione().toString(), Helper.toBinaryParameter(as.getByteWsdlDefinitorio()), // wsdldef
  185.                     Helper.toBinaryParameter(as.getByteWsdlConcettuale()), // wsdlconc,
  186.                     Helper.toBinaryParameter(as.getByteWsdlLogicoErogatore()), // wsdlserv
  187.                     Helper.toBinaryParameter(as.getByteWsdlLogicoFruitore()), // wsdlservcorr,
  188.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getFiltroDuplicati()),
  189.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConfermaRicezione()),
  190.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdCollaborazione()),
  191.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdRiferimentoRichiesta()),
  192.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConsegnaInOrdine()), "", // scadenza
  193.                     "0", // Id intero del servizio applicativo
  194.                     as.getSoggettoReferente().getId().toString(), // IDSoggetto?
  195.                     as.getVersione().toString(), null, // accordoCooperazione
  196.                     false, // visibilitaAccordoServizio
  197.                     false, // visibilitaAccordoCooperazione
  198.                     null, // ID AccordoOld
  199.                     new BinaryParameter(), // wsblconc
  200.                     new BinaryParameter(), // wsblserv
  201.                     new BinaryParameter(), // wsblservcorr
  202.                     validazioneDocumenti, env.tipo_protocollo, null, // backToStato
  203.                     env.apcCore.toMessageServiceBinding(as.getServiceBinding()), null, // messageType
  204.                     Enums.interfaceTypeFromFormatoSpecifica.get(as.getFormatoSpecifica()), env.gestisciSoggettoReferente,
  205.                     bfTags.toString(),
  206.                     canaleStato, canale, gestioneCanaliEnabled
  207.                     )) {

  209.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  210.             }
  211.             
  212.             ApiApiHelper.validateProperties(env, protocolProperties, idAccordoFromAccordo, ConsoleOperationType.ADD);
  213.             

  215.             List<Object> objectToCreate = new ArrayList<>();
  216.             
  217.             if(body.getTags()!=null && !body.getTags().isEmpty()) {
  218.                 as.setGruppi(new GruppiAccordo());
  219.                 
  220.                 GruppiCore gruppiCore = new GruppiCore(env.stationCore);
  221.                 
  222.                 for (String tag : body.getTags()) {
  223.                     GruppoAccordo gruppo = new GruppoAccordo();
  224.                     gruppo.setNome(tag);
  225.                     as.getGruppi().addGruppo(gruppo);
  226.                     
  227.                     if(!gruppiCore.existsGruppo(tag)) {
  228.                         Gruppo nuovoGruppo = new Gruppo();
  229.                         nuovoGruppo.setNome(tag);
  230.                         nuovoGruppo.setSuperUser(as.getSuperUser());
  231.                         objectToCreate.add(nuovoGruppo);
  232.                     }
  233.                 }
  234.             }
  235.             
  236.             objectToCreate.add(as);
  237.             
  238.             // effettuo le operazioni
  239.             env.apcCore.performCreateOperation(env.userLogin, false, objectToCreate.toArray(new Object[objectToCreate.size()]));
  240.             
  241.             context.getLogger().info("Invocazione completata con successo");
  242.             
  243.             // Bug Fix: altrimenti viene generato 204
  244.             context.getServletResponse().setStatus(201);
  245.             
  246.         } catch (javax.ws.rs.WebApplicationException e) {
  247.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  248.             throw e;
  249.         } catch (Throwable e) {
  250.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  251.             throw FaultCode.ERRORE_INTERNO.toException(e);
  252.         }
  253.     }

  255.     /**
  256.      * Creazione di un allegato di una API
  257.      *
  258.      * Questa operazione consente di aggiungere un allegato alla API identificata
  259.      * dal nome e dalla versione
  260.      *
  261.      */
  262.     @Override
  263.     public void createApiAllegato(ApiAllegato body, String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  264.         IContext context = this.getContext();
  265.         try {

  267.             context.getLogger().info("Invocazione in corso ...");

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

  272.             if (body == null)
  273.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Body non presente");

  275.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  276.             AccordoServizioParteComune as = Helper.getAccordoFull(nome, versione, env.idSoggetto.toIDSoggetto(), env.apcCore);

  278.             if (as == null)
  279.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nessuna Api corrisponde ai parametri indicati");

  281.             Documento documento = ApiApiHelper.apiAllegatoToDocumento(body, as, env);

  283.             if(RuoloAllegatoAPI.ALLEGATO.equals(body.getAllegato().getRuolo())) {
  284.                 as.addAllegato(documento);
  285.             }
  286.             else if(RuoloAllegatoAPI.SPECIFICASEMIFORMALE.equals(body.getAllegato().getRuolo())) {
  287.                 as.addSpecificaSemiformale(documento);
  288.             }else {
  289.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Ruolo " + body.getAllegato().getRuolo() + " sconosciuto");
  290.             }

  292.             ArchiviCore archiviCore = new ArchiviCore(env.stationCore);
  293.             SerialiableFormFile filewrap = new SerialiableFormFile(documento.getFile(), documento.getByteContenuto());

  295.             env.requestWrapper.overrideParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_RUOLO,
  296.                     documento.getRuolo());

  298.             ArchiviHelper archiviHelper = new ArchiviHelper(env.stationCore, env.requestWrapper, env.pd,
  299.                     env.requestWrapper.getSession());

  301.             boolean documentoUnivocoIndipendentementeTipo = true;
  302.             if (archiviCore.existsDocumento(documento, ProprietariDocumento.accordoServizio,
  303.                     documentoUnivocoIndipendentementeTipo)) {
  304.                 throw FaultCode.CONFLITTO.toException("Allegato con nome " + documento.getFile() + " già presente nella API");
  305.             }

  307.             if (!archiviHelper.accordiAllegatiCheckData(TipoOperazione.ADD, filewrap, documento,
  308.                     ProprietariDocumento.accordoServizio, env.protocolFactory)) {
  309.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  310.             }

  312.             env.apcCore.performUpdateOperation(env.userLogin, false, as);

  314.             context.getLogger().info("Invocazione completata con successo");
  315.             
  316.             // Bug Fix: altrimenti viene generato 204
  317.             context.getServletResponse().setStatus(201);
  318.             
  319.         } catch (javax.ws.rs.WebApplicationException e) {
  320.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  321.             throw e;
  322.         } catch (Throwable e) {
  323.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  324.             throw FaultCode.ERRORE_INTERNO.toException(e);
  325.         }
  326.     }

  328.     /**
  329.      * Creazione di un'azione di una API
  330.      *
  331.      * Questa operazione consente di aggiungere una azione al servizio della API
  332.      * identificata dal nome e dalla versione
  333.      *
  334.      */
  335.     @Override
  336.     public void createApiAzione(ApiAzione body, String nome, Integer versione, String nomeServizio, ProfiloEnum profilo,
  337.             String soggetto) {
  338.         IContext context = this.getContext();
  339.         // body.
  340.         try {
  341.             context.getLogger().info("Invocazione in corso ...");

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

  346.             if (body == null)
  347.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  349.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  350.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  352.             if (as == null)
  353.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nessuna Api con nome: " + nome + " e versione " + versione);
  354.             if (as.getServiceBinding() == ServiceBinding.REST)
  355.                 throw FaultCode.RICHIESTA_NON_VALIDA
  356.                         .toException("Non è possibile registrare Azioni e Servizi su Api con interfaccia REST");

  358.             PortType pt = as.getPortTypeList().stream().filter(p -> nomeServizio.equals(p.getNome())).findFirst()
  359.                     .orElse(null);

  361.             if (pt == null)
  362.                 throw FaultCode.NOT_FOUND.toException("Nessun Servizio con nome: " + nomeServizio);

  364.             Operation newOp = ApiApiHelper.apiAzioneToOperazione(body, pt);

  366.             if (env.apcCore.existsAccordoServizioPorttypeOperation(newOp.getNome(), pt.getId()))
  367.                 throw FaultCode.CONFLITTO.toException("L'azione " + newOp.getNome() + " è già stata associata alla Api");

  369.             ProtocolProperties protocolProperties = null;
  370.             if(profilo != null) {
  371.                 protocolProperties = ApiApiHelper.getProtocolProperties(body, profilo, as, newOp, env);
  372.     
  373.                 if(protocolProperties != null) {
  374.                     newOp.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  375.                 }
  376.             }

  378.             
  379.             pt.addAzione(newOp);
  380.             
  381.             ProfiloCollaborazioneEnum profiloBody = body.getProfiloCollaborazione()!=null ? body.getProfiloCollaborazione() : ProfiloCollaborazioneEnum.SINCRONO;
  382.             
  383.             if (! env.apcHelper.accordiPorttypeOperationCheckData(
  384.                     TipoOperazione.ADD,
  385.                     as.getId().toString(),
  386.                     nomeServizio,
  387.                     newOp.getNome(),
  388.                     newOp.getProfAzione(),
  389.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getFiltroDuplicati()),
  390.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getConfermaRicezione()),
  391.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getIdCollaborazione()),
  392.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getIdRiferimentoRichiesta()),
  393.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getConsegnaInOrdine()),
  394.                     newOp.getScadenza() != null ? newOp.getScadenza() : "", "-", // Servizio Correlato
  395.                     "-", // Azione Correlata
  396.                     Enums.profiloCollaborazioneFromApiEnum.get(profiloBody).toString(), "0", // styleOp
  397.                     "", // soapActionOp,
  398.                     "literal", // useOp,
  399.                     null, // opTypeOp,
  400.                     "" // nsWSDLOp
  401.             )) {
  402.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  403.             }
  404.             
  405.             IDPortType idPT = new IDPortType();
  406.             idPT.setNome(pt.getNome());
  407.             idPT.setIdAccordo(IDAccordoFactory.getInstance().getIDAccordoFromAccordo(as));
  408.             IDPortTypeAzione idAccordoAzione = new IDPortTypeAzione();
  409.             idAccordoAzione.setNome(newOp.getNome());
  410.             idAccordoAzione.setIdPortType(idPT);
  411.             
  412.             ApiApiHelper.validateProperties(env, protocolProperties, idAccordoAzione, ConsoleOperationType.ADD);
  413.             

  415.             AccordiServizioParteComuneUtilities.createPortTypeOperation(env.apcCore.isEnableAutoMappingWsdlIntoAccordo(),
  416.                     env.apcCore, env.apcHelper, as, pt, env.userLogin);

  418.             context.getLogger().info("Invocazione completata con successo");
  419.             
  420.             // Bug Fix: altrimenti viene generato 204
  421.             context.getServletResponse().setStatus(201);
  422.             
  423.         } catch (javax.ws.rs.WebApplicationException e) {
  424.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  425.             throw e;
  426.         } catch (Throwable e) {
  427.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  428.             throw FaultCode.ERRORE_INTERNO.toException(e);
  429.         }
  430.     }

  432.     /**
  433.      * Creazione di una risorsa di una API
  434.      *
  435.      * Questa operazione consente di aggiungere una risorsa alla API identificata
  436.      * dal nome e dalla versione
  437.      *
  438.      */
  439.     @Override
  440.     public void createApiRisorsa(ApiRisorsa body, String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  441.         IContext context = this.getContext();
  442.         try {
  443.             context.getLogger().info("Invocazione in corso ...");

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

  448.             if (body == null)
  449.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  451.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  452.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  454.             if (as == null)
  455.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nessuna Api con nome: " + nome + " e versione " + versione);

  457.             if (as.getServiceBinding() != ServiceBinding.REST) {
  458.                 throw FaultCode.RICHIESTA_NON_VALIDA
  459.                         .toException("E' possibile registrare risorse solo su API con interfaccia REST");
  460.             }

  462.             Resource newRes = ApiApiHelper.apiRisorsaToRegistro(body, as);

  464.             ProtocolProperties protocolProperties = null;
  465.             if(profilo != null) {
  466.                 protocolProperties = ApiApiHelper.getProtocolProperties(body, profilo, newRes, env);
  467.     
  468.                 if(protocolProperties != null) {
  469.                     newRes.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.ADD, null));
  470.                 }
  471.             }
  472.             

  474.             if (StringUtils.isEmpty(newRes.getNome()) && newRes.getMethod() == null)
  475.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il campo nome non è stato definito");

  477.             if (env.apcCore.existsAccordoServizioResource(newRes.getMethodRawEnumValue(), newRes.getPath(), as.getId(), null))
  478.                 throw FaultCode.CONFLITTO.toException("La risorsa " + newRes.getNome() + " è già stata associata alla Api");

  480.             if (!env.apcHelper.accordiResourceCheckData(TipoOperazione.ADD, as.getId().toString(),
  481.                     body.getNome() != null ? body.getNome() : "", newRes.getNome(), newRes.getPath(), newRes.getMethodRawEnumValue(),
  482.                     newRes.getDescrizione(), env.apcCore.toMessageMessageType(newRes.getMessageType()), null, // oldNomeRisorsa
  483.                     null, // oldNomeRisorsaGenerato
  484.                     null, // oldPath
  485.                     null, // oldHttpMethod
  486.                     AccordiServizioParteComuneCostanti.INFORMAZIONI_PROTOCOLLO_MODALITA_DEFAULT,
  487.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getFiltroDuplicati()),
  488.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getConfermaRicezione()), // confricaz,
  489.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getIdCollaborazione()),
  490.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getIdRiferimentoRichiesta()),
  491.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getConsegnaInOrdine()), // consordaz,
  492.                     "" // scadenzaaz
  493.             )) {
  494.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  495.             }

  497.             IDResource idResource = new IDResource();
  498.             idResource.setNome(newRes.getNome());
  499.             idResource.setIdAccordo(IDAccordoFactory.getInstance().getIDAccordoFromAccordo(as));
  500.             
  501.             ApiApiHelper.validateProperties(env, protocolProperties, idResource, newRes.getMethod()!=null ? newRes.getMethod().toString() : null, newRes.getPath(), ConsoleOperationType.ADD);
  502.             
  503.             as.addResource(newRes);

  505.             AccordiServizioParteComuneUtilities.createResource(env.apcCore.isEnableAutoMappingWsdlIntoAccordo(), env.apcCore,
  506.                     env.apcHelper, as, env.userLogin);

  508.             context.getLogger().info("Invocazione completata con successo");
  509.             
  510.             // Bug Fix: altrimenti viene generato 204
  511.             context.getServletResponse().setStatus(201);
  512.             
  513.         } catch (javax.ws.rs.WebApplicationException e) {
  514.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  515.             throw e;
  516.         } catch (Throwable e) {
  517.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  518.             throw FaultCode.ERRORE_INTERNO.toException(e);
  519.         }
  520.     }

  522.     /**
  523.      * Creazione di un servizio di una API
  524.      *
  525.      * Questa operazione consente di aggiungere un servizio alla API identificata
  526.      * dal nome e dalla versione
  527.      *
  528.      */
  529.     @Override
  530.     public void createApiServizio(ApiServizio body, String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  531.         IContext context = this.getContext();
  532.         try {
  533.             context.getLogger().info("Invocazione in corso ...");

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

  538.             if (body == null)
  539.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  541.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  542.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  544.             if (as == null)
  545.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nessuna Api con nome: " + nome + " e versione " + versione);

  547.             if (as.getServiceBinding() == ServiceBinding.REST) {
  548.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è possibile associare un servizio ad una api REST");
  549.             }

  551.             // Il Servizio assumiamo che di base RIDEFINISCA il profilo della api, dato che
  552.             // abbiamo nei campi dei valori che dalla console sono configurabili sono in
  553.             // quel caso.
  554.             PortType newPT = ApiApiHelper.apiServizioToRegistro(body, as, env);

  556.             if (env.apcCore.existsAccordoServizioPorttype(newPT.getNome(), as.getId()))
  557.                 throw FaultCode.CONFLITTO.toException("Il servizio " + newPT.getNome() + " è già stato associato alla API");

  559.             if (!env.apcHelper.accordiPorttypeCheckData(TipoOperazione.ADD, as.getId().toString(), newPT.getNome(),
  560.                     newPT.getDescrizione(), AccordiServizioParteComuneCostanti.INFORMAZIONI_PROTOCOLLO_MODALITA_RIDEFINITO,
  561.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPT.getFiltroDuplicati()),
  562.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPT.getConfermaRicezione()),
  563.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPT.getIdCollaborazione()),
  564.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPT.getIdRiferimentoRichiesta()),
  565.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPT.getConsegnaInOrdine()),
  566.                     newPT.getScadenza())) {
  567.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  568.             }
  569.             as.addPortType(newPT);

  571.             env.apcCore.performUpdateOperation(env.userLogin, false, as);

  573.             context.getLogger().info("Invocazione completata con successo");
  574.             
  575.             // Bug Fix: altrimenti viene generato 204
  576.             context.getServletResponse().setStatus(201);
  577.             
  578.         } catch (javax.ws.rs.WebApplicationException e) {
  579.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  580.             throw e;
  581.         } catch (Throwable e) {
  582.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  583.             throw FaultCode.ERRORE_INTERNO.toException(e);
  584.         }
  585.     }

  587.     /**
  588.      * Elimina un'api
  589.      *
  590.      * Questa operazione consente di eliminare un API identificata dal nome e dalla
  591.      * versione
  592.      *
  593.      */
  594.     @Override
  595.     public void deleteApi(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  596.         IContext context = this.getContext();
  597.         try {
  598.             context.getLogger().info("Invocazione in corso ...");

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

  603.             ApiEnv env = new ApiEnv(profilo, soggetto, context);

  605.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  607.             if (as != null) {
  608.                 StringBuilder inUsoMessage = new StringBuilder();
  609.                 
  610.                 AccordiServizioParteComuneUtilities.deleteAccordoServizioParteComune(as, env.userLogin, env.apcCore,
  611.                         env.apcHelper, inUsoMessage, "\n");
  612.                 if (inUsoMessage.length() > 0)
  613.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(inUsoMessage.toString()));
  614.             }

  616.             if (env.delete_404 && as == null)
  617.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

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

  621.         } catch (javax.ws.rs.WebApplicationException e) {
  622.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  623.             throw e;
  624.         } catch (Throwable e) {
  625.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  626.             throw FaultCode.ERRORE_INTERNO.toException(e);
  627.         }
  628.     }

  630.     /**
  631.      * Elimina un allegato di una API
  632.      *
  633.      * Questa operazione consente di eliminare un'allegato della API identificata
  634.      * dal nome e dalla versione
  635.      *
  636.      */
  637.     @Override
  638.     public void deleteApiAllegato(String nome, Integer versione, String nomeAllegato, ProfiloEnum profilo,
  639.             String soggetto) {
  640.         IContext context = this.getContext();
  641.         try {
  642.             context.getLogger().info("Invocazione in corso ...");

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

  647.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  648.             final AccordoServizioParteComune as = BaseHelper
  649.                     .supplyOrNotFound(() -> ApiApiHelper.getAccordoFull(nome, versione, env), "API");
  650.             final Documento toDel = BaseHelper.evalnull(() -> env.archiviCore.getDocumento(nomeAllegato, null, null,
  651.                     as.getId(), false, ProprietariDocumento.accordoServizio)

  653.             );

  655.             if (toDel != null) {
  656.                 AccordiServizioParteComuneUtilities.deleteAccordoServizioParteComuneAllegati(as, env.userLogin, env.apcCore,
  657.                         env.apcHelper, Arrays.asList(toDel.getId()));
  658.             }

  660.             if (env.delete_404 && toDel == null)
  661.                 throw FaultCode.NOT_FOUND
  662.                         .toException("Allegato con nome " + nomeAllegato + " non presente per il servizio applicativo scelto.");

  664.             context.getLogger().info("Invocazione completata con successo");
  665.         } catch (javax.ws.rs.WebApplicationException e) {
  666.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  667.             throw e;
  668.         } catch (Throwable e) {
  669.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  670.             throw FaultCode.ERRORE_INTERNO.toException(e);
  671.         }
  672.     }

  674.     /**
  675.      * Elimina un'azione del servizio di una API
  676.      *
  677.      * Questa operazione consente di eliminare un'azione del servizio della API
  678.      * identificata dal nome e dalla versione
  679.      *
  680.      */
  681.     @Override
  682.     public void deleteApiAzione(String nome, Integer versione, String nomeServizio, String nomeAzione,
  683.             ProfiloEnum profilo, String soggetto) {
  684.         IContext context = this.getContext();
  685.         try {
  686.             context.getLogger().info("Invocazione in corso ...");

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

  691.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  692.             AccordoServizioParteComune as = BaseHelper
  693.                     .supplyOrNotFound(() -> ApiApiHelper.getAccordoFull(nome, versione, env), "API");

  695.             PortType pt = null;
  696.             for (int i = 0; i < as.sizePortTypeList(); i++) {
  697.                 pt = as.getPortType(i);
  698.                 if (nomeServizio.equals(pt.getNome()))
  699.                     break;
  700.             }

  702.             if (pt == null)
  703.                 throw FaultCode.NOT_FOUND.toException("Nessun Servizio registrato sulla api con nome " + nomeServizio);

  705.             if (BaseHelper.findFirst(pt.getAzioneList(), op -> op.getNome().equals(nomeAzione)).isPresent()) {
  706.                 StringBuilder inUsoMessage = new StringBuilder();

  708.                 AccordiServizioParteComuneUtilities.deleteAccordoServizioParteComuneOperations(as, env.userLogin, env.apcCore,
  709.                         env.apcHelper, inUsoMessage, "\n", pt, Arrays.asList(nomeAzione));

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

  714.             }

  716.             else if (env.delete_404) {
  717.                 throw FaultCode.NOT_FOUND.toException("Azione " + nomeAzione + " non registrata sul servizio " + nomeServizio);
  718.             }

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

  722.         } catch (javax.ws.rs.WebApplicationException e) {
  723.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  724.             throw e;
  725.         } catch (Throwable e) {
  726.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  727.             throw FaultCode.ERRORE_INTERNO.toException(e);
  728.         }
  729.     }

  731.     /**
  732.      * Elimina una risorsa di una API
  733.      *
  734.      * Questa operazione consente di eliminare una risorsa della API identificata
  735.      * dal nome e dalla versione
  736.      *
  737.      */
  738.     @Override
  739.     public void deleteApiRisorsa(String nome, Integer versione, String nomeRisorsa, ProfiloEnum profilo,
  740.             String soggetto) {
  741.         IContext context = this.getContext();
  742.         try {
  743.             context.getLogger().info("Invocazione in corso ...");

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

  748.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  749.             final AccordoServizioParteComune as = BaseHelper
  750.                     .supplyOrNotFound(() -> ApiApiHelper.getAccordoFull(nome, versione, env), "API");

  752.             if (BaseHelper.findFirst(as.getResourceList(), res -> res.getNome().equals(nomeRisorsa)).isPresent()) {

  754.                 StringBuilder inUsoMessage = new StringBuilder();
  755.                 AccordiServizioParteComuneUtilities.deleteAccordoServizioParteComuneRisorse(as, env.userLogin, env.apcCore,
  756.                         env.apcHelper, inUsoMessage, "\n", Arrays.asList(nomeRisorsa));

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

  761.             } else if (env.delete_404) {
  762.                 throw FaultCode.NOT_FOUND.toException("Risorsa " + nomeRisorsa + " non associata alla API ");
  763.             }

  765.             context.getLogger().info("Invocazione completata con successo");
  766.         } catch (javax.ws.rs.WebApplicationException e) {
  767.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  768.             throw e;
  769.         } catch (Throwable e) {
  770.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  771.             throw FaultCode.ERRORE_INTERNO.toException(e);
  772.         }
  773.     }

  775.     /**
  776.      * Elimina un servizio di una API
  777.      *
  778.      * Questa operazione consente di eliminare un servizio della API identificata
  779.      * dal nome e dalla versione
  780.      *
  781.      */
  782.     @Override
  783.     public void deleteApiServizio(String nome, Integer versione, String nomeServizio, ProfiloEnum profilo,
  784.             String soggetto) {
  785.         IContext context = this.getContext();
  786.         try {
  787.             context.getLogger().info("Invocazione in corso ...");

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

  792.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  793.             final AccordoServizioParteComune as = BaseHelper
  794.                     .supplyOrNotFound(() -> ApiApiHelper.getAccordoFull(nome, versione, env), "API");

  796.             if (BaseHelper.findFirst(as.getPortTypeList(), pt -> pt.getNome().equals(nomeServizio)).isPresent()) {

  798.                 final StringBuilder inUsoMessage = new StringBuilder();
  799.                 AccordiServizioParteComuneUtilities.deleteAccordoServizioParteComunePortTypes(as, env.userLogin, env.apcCore,
  800.                         env.apcHelper, inUsoMessage, "\n", Arrays.asList(nomeServizio));

  802.                 if (inUsoMessage.length() > 0) {
  803.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(inUsoMessage.toString()));
  804.                 }

  806.             } else if (env.delete_404) {
  807.                 throw FaultCode.NOT_FOUND.toException("Servizio " + nomeServizio + " non associato alla API");
  808.             }

  810.             context.getLogger().info("Invocazione completata con successo");
  811.         } catch (javax.ws.rs.WebApplicationException e) {
  812.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  813.             throw e;
  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 l'allegato di una API
  822.      *
  823.      * Questa operazione consente di ottenere l'allegato di una API identificata dal
  824.      * nome e dalla versione
  825.      *
  826.      */
  827.     @Override
  828.     public byte[] downloadApiAllegato(String nome, Integer versione, String nomeAllegato, ProfiloEnum profilo,
  829.             String soggetto) {
  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 ApiEnv env = new ApiEnv(profilo, soggetto, context);
  838.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  840.             if (as == null)
  841.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

  843.             Documento doc = as.getAllegatoList().stream().filter(a -> nomeAllegato.equals(a.getFile())).findFirst()
  844.                     .orElse(null);

  846.             if (doc == null) {
  847.                 doc = as.getSpecificaSemiformaleList().stream().filter(a -> nomeAllegato.equals(a.getFile())).findFirst()
  848.                         .orElse(null);
  849.             }
  850.             
  851.             if (doc == null)
  852.                 throw FaultCode.NOT_FOUND
  853.                         .toException("Nessun allegato con nome " + nomeAllegato + " registrato per la Api specificata");

  855.             doc = env.archiviCore.getDocumento(doc.getFile(), doc.getTipo(), doc.getRuolo(), doc.getIdProprietarioDocumento(),
  856.                     true, ProprietariDocumento.accordoServizio);

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

  860.             Helper.setContentType(context, doc.getFile());
  861.             
  862.             return doc.getByteContenuto();
  863.         } catch (javax.ws.rs.WebApplicationException e) {
  864.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  865.             throw e;
  866.         } catch (Throwable e) {
  867.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  868.             throw FaultCode.ERRORE_INTERNO.toException(e);
  869.         }
  870.     }

  872.     /**
  873.      * Restituisce l'interfaccia di una API
  874.      *
  875.      * Questa operazione consente di ottenere l'interfaccia di una API identificata
  876.      * dal nome e dalla versione
  877.      *
  878.      */
  879.     @Override
  880.     public byte[] downloadApiInterfaccia(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  881.         IContext context = this.getContext();
  882.         try {
  883.             // ApiInterfacciaView a = new ApiInterfacciaView();

  885.             context.getLogger().info("Invocazione in corso ...");

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

  890.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  891.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  893.             if (as == null)
  894.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

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

  898.             byte [] spec = null;
  899.             switch (as.getServiceBinding()) {
  900.             case REST:
  901.                 spec = as.getByteWsdlConcettuale();
  902.                 break;
  903.             case SOAP:
  904.                 spec = as.getByteWsdlLogicoErogatore();
  905.                 break;
  906.             }
  907.             
  908.             String fileName = null;
  909.             switch (as.getFormatoSpecifica()) {
  910.             case WSDL_11:
  911.                 fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_CONCETTUALE_WSDL;
  912.                 break;
  913.             case OPEN_API_3:
  914.                 YAMLUtils yamlUtils = YAMLUtils.getInstance();
  915.                 if(yamlUtils.isYaml(spec)) {
  916.                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_OPENAPI_3_0_YAML;
  917.                 }
  918.                 else {  
  919.                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_OPENAPI_3_0_JSON;
  920.                 }
  921.                 break;
  922.             case SWAGGER_2:
  923.                 yamlUtils = YAMLUtils.getInstance();
  924.                 if(yamlUtils.isYaml(spec)) {
  925.                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SWAGGER_2_0_YAML;
  926.                 }
  927.                 else {
  928.                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SWAGGER_2_0_JSON;
  929.                 }
  930.                 break;
  931.             case WADL:
  932.                 fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WADL;
  933.                 break;
  934.             }
  935.             
  936.             if(fileName!=null) {
  937.                 Helper.setContentType(context, fileName);
  938.             }
  939.             
  940.             return spec;
  941.         } catch (javax.ws.rs.WebApplicationException e) {
  942.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  943.             throw e;
  944.         } catch (Throwable e) {
  945.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  946.             throw FaultCode.ERRORE_INTERNO.toException(e);
  947.         }
  948.     }

  950.     /**
  951.      * Ricerca api
  952.      *
  953.      * Elenca le API registrate
  954.      *
  955.      */
  956.     @Override
  957.     public ListaApi findAllApi(ProfiloEnum profilo, String soggetto, String q, Integer limit, Integer offset,
  958.             TipoApiEnum tipoApi, String tag, Boolean profiloQualsiasi) {
  959.         IContext context = this.getContext();
  960.         try {
  961.             context.getLogger().info("Invocazione in corso ...");

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

  966.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);

  968.             final int idLista = Liste.ACCORDI;
  969.             final ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  970.                     env.tipo_protocollo);

  972.             if(profiloQualsiasi!=null && profiloQualsiasi) {
  973.                 ricerca.clearFilter(idLista, Filtri.FILTRO_PROTOCOLLO);
  974.             }
  975.             
  976.             if (tipoApi != null)
  977.                 ricerca.addFilter(idLista, Filtri.FILTRO_SERVICE_BINDING, Enums.serviceBindingFromTipo.get(tipoApi).toString().toLowerCase());
  978.             
  979.             if(tag!=null) {
  980.                 ricerca.addFilter(idLista, Filtri.FILTRO_GRUPPO, tag);
  981.             }

  983.             final String tipoAccordo = "apc"; // Dal debug.
  984.             final List<AccordoServizioParteComuneSintetico> lista = AccordiServizioParteComuneUtilities
  985.                     .accordiList(env.apcCore, env.userLogin, ricerca, tipoAccordo);
  986.             
  987.             final ListaApi ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  988.                     ricerca.getIndexIniziale(idLista),
  989.                     ricerca.getPageSize(idLista), 
  990.                     ricerca.getNumEntries(idLista), ListaApi.class);

  992.             if (env.findall_404 && lista.isEmpty())
  993.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api corrisponde ai criteri di ricerca");

  995.             lista.forEach(as -> ret
  996.                     .addItemsItem(ApiApiHelper.apiToItem(ApiApiHelper.accordoSpcRegistroToApi(as, env.soggettiCore), as, env)));

  998.             context.getLogger().info("Invocazione completata con successo");
  999.             return ret;

  1001.         } catch (javax.ws.rs.WebApplicationException e) {
  1002.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1003.             throw e;
  1004.         } catch (Throwable e) {
  1005.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1006.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1007.         }
  1008.     }

  1010.     /**
  1011.      * Elenco allegati di una API
  1012.      *
  1013.      * Questa operazione consente di ottenere gli allegati di una API identificata
  1014.      * dal nome e dalla versione
  1015.      *
  1016.      */
  1017.     @Override
  1018.     public ListaApiAllegati findAllApiAllegati(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  1019.             String q, Integer limit, Integer offset) {
  1020.         IContext context = this.getContext();
  1021.         try {
  1022.             context.getLogger().info("Invocazione in corso ...");

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

  1027.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1028.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1030.             if (as == null)
  1031.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

  1033.             int idLista = Liste.ACCORDI_ALLEGATI;
  1034.             ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  1035.                     env.tipo_protocollo);

  1037.             List<Documento> docsRegistro = env.apcCore.accordiAllegatiList(as.getId().intValue(), ricerca);

  1039.             if (docsRegistro.size() == 0 && env.findall_404)
  1040.                 throw FaultCode.NOT_FOUND.toException("Nessun allegato dell'Api specificata corrisponde ai criteri di ricerca");

  1042.             final ListaApiAllegati ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(),
  1043.                     ricerca.getIndexIniziale(idLista),
  1044.                     ricerca.getPageSize(idLista), 
  1045.                     ricerca.getNumEntries(idLista), ListaApiAllegati.class);
  1046.             docsRegistro.forEach(d -> ret.addItemsItem(ApiApiHelper.documentoToApiAllegatoItem(d)));

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

  1050.             return ret;

  1052.         } catch (javax.ws.rs.WebApplicationException e) {
  1053.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1054.             throw e;
  1055.         } catch (Throwable e) {
  1056.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1057.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1058.         }
  1059.     }

  1061.     /**
  1062.      * Elenco servizi di una API
  1063.      *
  1064.      * Questa operazione consente di ottenere le azioni di un servizio della API
  1065.      * identificata dal nome e dalla versione
  1066.      *
  1067.      */
  1068.     @Override
  1069.     public ListaApiAzioni findAllApiAzioni(String nome, Integer versione, String nomeServizio, ProfiloEnum profilo,
  1070.             String soggetto, String q, Integer limit, Integer offset) {
  1071.         IContext context = this.getContext();
  1072.         try {
  1073.             context.getLogger().info("Invocazione in corso ...");

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

  1078.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1079.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1081.             if (as == null)
  1082.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

  1084.             int idLista = Liste.ACCORDI_PORTTYPE_AZIONI;
  1085.             ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  1086.                     env.tipo_protocollo);

  1088.             PortType pt = as.getPortTypeList().stream().filter(p -> nomeServizio.equals(p.getNome())).findFirst()
  1089.                     .orElse(null);

  1091.             if (pt == null)
  1092.                 throw FaultCode.NOT_FOUND
  1093.                         .toException("Non è stato trovato alcun servizio con nome " + nomeServizio + " legato alla Api");

  1095.             List<Operation> azioniServizio = env.apcCore.accordiPorttypeOperationList(pt.getId().intValue(), ricerca);

  1097.             if (azioniServizio.size() == 0 && env.findall_404)
  1098.                 throw FaultCode.NOT_FOUND.toException("Nessua azione dell'Api specificata corrisponde ai criteri di ricerca");

  1100.             final ListaApiAzioni ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(), 
  1101.                     ricerca.getIndexIniziale(idLista),
  1102.                     ricerca.getPageSize(idLista), 
  1103.                     ricerca.getNumEntries(idLista), ListaApiAzioni.class);

  1105.             azioniServizio.forEach(op -> ret.addItemsItem(ApiApiHelper.operazioneToApiAzione(op)));

  1107.             context.getLogger().info("Invocazione completata con successo");
  1108.             return ret;

  1110.         } catch (javax.ws.rs.WebApplicationException e) {
  1111.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1112.             throw e;
  1113.         } catch (Throwable e) {
  1114.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1115.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1116.         }
  1117.     }

  1119.     /**
  1120.      * Elenco risorse di una API
  1121.      *
  1122.      * Questa operazione consente di ottenere le risorse di una API identificata dal
  1123.      * nome e dalla versione
  1124.      *
  1125.      */
  1126.     @Override
  1127.     public ListaApiRisorse findAllApiRisorse(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  1128.             String q, Integer limit, Integer offset, HttpMethodEnum httpMethod) {
  1129.         IContext context = this.getContext();
  1130.         try {
  1131.             context.getLogger().info("Invocazione in corso ...");

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

  1136.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1137.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1139.             if (as == null)
  1140.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

  1142.             int idLista = Liste.ACCORDI_API_RESOURCES;

  1144.             ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  1145.                     env.tipo_protocollo);

  1147.             if (httpMethod != null)
  1148.                 ricerca.addFilter(idLista, Filtri.FILTRO_HTTP_METHOD, httpMethod.toString());

  1150.             final ListaApiRisorse ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(),
  1151.                     ricerca.getIndexIniziale(idLista),
  1152.                     ricerca.getPageSize(idLista), 
  1153.                     ricerca.getNumEntries(idLista), ListaApiRisorse.class);
  1154.             List<Resource> risorse = env.apcCore.accordiResourceList(as.getId().intValue(), ricerca);

  1156.             if (risorse.size() == 0 && env.findall_404)
  1157.                 throw FaultCode.NOT_FOUND.toException("Nessun allegato dell'Api specificata corrisponde ai criteri di ricerca");

  1159.             risorse.forEach(r -> ret.addItemsItem(ApiApiHelper.risorsaRegistroToApi(r)));

  1161.             context.getLogger().info("Invocazione completata con successo");
  1162.             return ret;

  1164.         } catch (javax.ws.rs.WebApplicationException e) {
  1165.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1166.             throw e;
  1167.         } catch (Throwable e) {
  1168.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1169.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1170.         }
  1171.     }

  1173.     /**
  1174.      * Elenco servizi di una API
  1175.      *
  1176.      * Questa operazione consente di ottenere i servizi di una API identificata dal
  1177.      * nome e dalla versione
  1178.      *
  1179.      */
  1180.     @Override
  1181.     public ListaApiServizi findAllApiServizi(String nome, Integer versione, ProfiloEnum profilo, String soggetto,
  1182.             String q, Integer limit, Integer offset) {
  1183.         IContext context = this.getContext();
  1184.         try {
  1185.             context.getLogger().info("Invocazione in corso ...");

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

  1190.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1191.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1193.             if (as == null)
  1194.                 throw FaultCode.NOT_FOUND.toException("Api non trovata");

  1196.             int idLista = Liste.ACCORDI_PORTTYPE;

  1198.             ConsoleSearch ricerca = Helper.setupRicercaPaginata(q, limit, offset, idLista, env.idSoggetto.toIDSoggetto(),
  1199.                     env.tipo_protocollo);

  1201.             List<PortType> servizi = env.apcCore.accordiPorttypeList(as.getId().intValue(), ricerca);

  1203.             final ListaApiServizi ret = ListaUtils.costruisciListaPaginata(context.getUriInfo(),
  1204.                     ricerca.getIndexIniziale(idLista),
  1205.                     ricerca.getPageSize(idLista), 
  1206.                     ricerca.getNumEntries(idLista), ListaApiServizi.class);

  1208.             if (servizi.size() == 0 && env.findall_404)
  1209.                 throw FaultCode.NOT_FOUND.toException("Nessun allegato dell'Api specificata corrisponde ai criteri di ricerca");

  1211.             servizi.forEach(s -> ret.addItemsItem(ApiApiHelper.servizioRegistroToApi(s)));

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

  1224.     /**
  1225.      * Restituisce i dettagli di una API
  1226.      *
  1227.      * Questa operazione consente di ottenere i dettagli di una API identificata dal
  1228.      * nome e dalla versione
  1229.      *
  1230.      */
  1231.     @Override
  1232.     public ApiViewItem getApi(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1233.         IContext context = this.getContext();
  1234.         try {
  1235.             context.getLogger().info("Invocazione in corso ...");

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

  1240.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1241.             AccordoServizioParteComuneSintetico as = ApiApiHelper.getAccordoSintetico(nome, versione, env);

  1243.             if (as == null)
  1244.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1246.             ApiItem item = ApiApiHelper.apiToItem(ApiApiHelper.accordoSpcRegistroToApi(as, env.soggettiCore), as, env);
  1247.             ApiViewItem ret = new ApiViewItem();

  1249.             ret.setDescrizione(item.getDescrizione());
  1250.             ret.setTipoInterfaccia(item.getTipoInterfaccia());
  1251.             ret.setNome(item.getNome());
  1252.             ret.setProfilo(item.getProfilo());
  1253.             ret.setReferente(item.getSoggetto());
  1254.             ret.setSoggetto(item.getSoggetto());
  1255.             ret.setVersione(item.getVersione());
  1256.             ret.setStato(item.getStato());
  1257.             ret.setStatoDescrizione(item.getStatoDescrizione());
  1258.             ret.setTags(item.getTags());
  1259.             ret.setCanale(item.getCanale());
  1260.             context.getLogger().info("Invocazione completata con successo");
  1261.             return ret;

  1263.         } catch (javax.ws.rs.WebApplicationException e) {
  1264.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1265.             throw e;
  1266.         } catch (Throwable e) {
  1267.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1268.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1269.         }
  1270.     }

  1272.     /**
  1273.      * Restituisce il dettaglio di un allegato di una API
  1274.      *
  1275.      * Questa operazione consente di ottenere il dettaglio di un allegato della API
  1276.      * identificata dal nome e dalla versione
  1277.      *
  1278.      */
  1279.     @Override
  1280.     public ApiAllegato getApiAllegato(String nome, Integer versione, String nomeAllegato, ProfiloEnum profilo,
  1281.             String soggetto) {
  1282.         IContext context = this.getContext();
  1283.         try {
  1284.             context.getLogger().info("Invocazione in corso ...");

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

  1289.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1290.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1292.             if (as == null)
  1293.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1295.             ApiAllegato ret = as.getAllegatoList().stream().filter(a -> nomeAllegato.equals(a.getFile())).map(a -> {
  1296.                 try {
  1297.                     return ApiApiHelper.documentoToApiAllegato(env.archiviCore.getDocumento(a.getId(), true));
  1298.                 } catch (Exception e) {
  1299.                     return null;
  1300.                 }
  1301.             }).findFirst().orElse(null);
  1302.             
  1303.             if(ret==null) {
  1304.                 ret = as.getSpecificaSemiformaleList().stream().filter(a -> nomeAllegato.equals(a.getFile())).map(a -> {
  1305.                     try {
  1306.                         return ApiApiHelper.documentoToApiAllegato(env.archiviCore.getDocumento(a.getId(), true));
  1307.                     } catch (Exception e) {
  1308.                         return null;
  1309.                     }
  1310.                 }).findFirst().orElse(null);
  1311.             }

  1313.             if (ret == null)
  1314.                 throw FaultCode.NOT_FOUND
  1315.                         .toException("Nessun allegato con nome " + nomeAllegato + " registrato per la Api specificata");

  1317.             context.getLogger().info("Invocazione completata con successo");
  1318.             return ret;

  1320.         } catch (javax.ws.rs.WebApplicationException e) {
  1321.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1322.             throw e;
  1323.         } catch (Throwable e) {
  1324.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1325.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1326.         }
  1327.     }

  1329.     /**
  1330.      * Restituisce il dettaglio di un'azione di un servizio della API
  1331.      *
  1332.      * Questa operazione consente di ottenere il dettaglio di un'azione nel servizio
  1333.      * della API identificata dal nome e dalla versione
  1334.      *
  1335.      */
  1336.     @Override
  1337.     public ApiAzione getApiAzione(String nome, Integer versione, String nomeServizio, String nomeAzione,
  1338.             ProfiloEnum profilo, String soggetto) {
  1339.         IContext context = this.getContext();
  1340.         try {
  1341.             context.getLogger().info("Invocazione in corso ...");

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

  1346.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1347.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1349.             if (as == null)
  1350.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1352.             PortType pt = as.getPortTypeList().stream().filter(p -> nomeServizio.equals(p.getNome())).findFirst()
  1353.                     .orElse(null);

  1355.             if (pt == null)
  1356.                 throw FaultCode.NOT_FOUND.toException("Nessun Servizio con nome: " + nomeServizio);

  1358.             Operation az = pt.getAzioneList().stream().filter(a -> nomeAzione.equals(a.getNome()))
  1359.                     .findFirst().orElse(null);

  1361.             if (az == null)
  1362.                 throw FaultCode.NOT_FOUND
  1363.                         .toException("Nessuna azione con nome " + nomeAzione + " registrato per il servizio " + nomeServizio);

  1365.             ApiAzione ret = ApiApiHelper.operazioneToApiAzione(az);

  1367.             ApiApiHelper.populateApiAzioneWithProtocolInfo(as, az, env, profilo, ret);

  1369.             context.getLogger().info("Invocazione completata con successo");
  1370.             return ret;

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

  1381.     /*
  1382.      * Restituisce il canale associato all'API
  1383.      *
  1384.      * Questa operazione consente di ottenere il canale associato all'API identificata dal nome e dalla versione
  1385.      *
  1386.      */
  1387.     @Override
  1388.     public ApiCanale getApiCanale(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1389.         IContext context = this.getContext();
  1390.         try {
  1391.             context.getLogger().info("Invocazione in corso ...");     

  1393.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1394.             context.getLogger().debug("Autorizzazione completata con successo");     
  1395.                         
  1396.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1397.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1399.             if (as == null)
  1400.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1402.             ApiCanale canale = null;
  1403.             if(env.gestioneCanali) {
  1404.                 canale = new ApiCanale();
  1405.                 if(as.getCanale()!=null && !"".equals(as.getCanale())) {
  1406.                     canale.setNome(as.getCanale());
  1407.                     canale.setConfigurazione(CanaleEnum.API);
  1408.                 }
  1409.                 else {
  1410.                     canale.setNome(env.canaleDefault);
  1411.                     canale.setConfigurazione(CanaleEnum.DEFAULT);
  1412.                 }
  1413.             }
  1414.             else {
  1415.                 throw new Exception("Gestione dei canali non abilitata");
  1416.             }
  1417.             
  1418.             context.getLogger().info("Invocazione completata con successo");
  1419.             return canale;
  1420.      
  1421.         }
  1422.         catch(javax.ws.rs.WebApplicationException e) {
  1423.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  1424.             throw e;
  1425.         }
  1426.         catch(Throwable e) {
  1427.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  1428.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1429.         }
  1430.     }

  1432.     /**
  1433.      * Restituisce la descrizione di una API
  1434.      *
  1435.      * Questa operazione consente di ottenere la descrizione di una API identificata
  1436.      * dal nome e dalla versione
  1437.      *
  1438.      */
  1439.     @Override
  1440.     public ApiDescrizione getApiDescrizione(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1441.         IContext context = this.getContext();
  1442.         try {
  1443.             context.getLogger().info("Invocazione in corso ...");

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

  1448.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1449.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1451.             if (as == null)
  1452.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1454.             ApiDescrizione ret = new ApiDescrizione();
  1455.             ret.setDescrizione(as.getDescrizione());

  1457.             context.getLogger().info("Invocazione completata con successo");
  1458.             return ret;

  1460.         } catch (javax.ws.rs.WebApplicationException e) {
  1461.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1462.             throw e;
  1463.         } catch (Throwable e) {
  1464.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1465.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1466.         }
  1467.     }

  1469.     /**
  1470.      * Restituisce le informazioni generali di una API
  1471.      *
  1472.      * Questa operazione consente di ottenere le informazioni generali di una API
  1473.      * identificata dal nome e dalla versione
  1474.      *
  1475.      */
  1476.     @Override
  1477.     public ApiInformazioniGeneraliView getApiInformazioniGenerali(String nome, Integer versione, ProfiloEnum profilo,
  1478.             String soggetto) {
  1479.         IContext context = this.getContext();
  1480.         try {
  1481.             context.getLogger().info("Invocazione in corso ...");

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

  1486.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1487.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1489.             if (as == null)
  1490.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1492.             ApiInformazioniGeneraliView ret = new ApiInformazioniGeneraliView();

  1494.             ret.setNome(as.getNome());
  1495.             ret.setProfilo(env.profilo);
  1496.             ret.setVersione(as.getVersione());

  1498.             context.getLogger().info("Invocazione completata con successo");
  1499.             return ret;

  1501.         } catch (javax.ws.rs.WebApplicationException e) {
  1502.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1503.             throw e;
  1504.         } catch (Throwable e) {
  1505.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1506.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1507.         }
  1508.     }

  1510.     /**
  1511.      * Restituisce l'interfaccia di una API
  1512.      *
  1513.      * Questa operazione consente di ottenere l'interfaccia di una API identificata
  1514.      * dal nome e dalla versione
  1515.      *
  1516.      */
  1517.     @Override
  1518.     public ApiInterfacciaView getApiInterfaccia(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1519.         IContext context = this.getContext();
  1520.         try {
  1521.             context.getLogger().info("Invocazione in corso ...");

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

  1526.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1527.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1529.             if (as == null)
  1530.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1532.             ApiInterfacciaView ret = new ApiInterfacciaView();

  1534.             ret.setProfilo(env.profilo);
  1535.             
  1536.             TipoApiEnum protocollo = as.getServiceBinding() == ServiceBinding.REST ? TipoApiEnum.REST : TipoApiEnum.SOAP;
  1537.             
  1538.             switch (protocollo) {
  1539.             case REST:
  1540.                 ApiInterfacciaRest iRest = new ApiInterfacciaRest();
  1541.                 iRest.setProtocollo(protocollo);
  1542.                 iRest.setFormato(Enums.formatoRestFromSpecifica.get(as.getFormatoSpecifica()));
  1543.                 ret.setTipoInterfaccia(iRest);
  1544.                 ret.setInterfaccia(as.getByteWsdlConcettuale());
  1545.                 break;
  1546.             case SOAP:
  1547.                 ApiInterfacciaSoap iSoap = new ApiInterfacciaSoap();
  1548.                 iSoap.setProtocollo(protocollo);
  1549.                 iSoap.setFormato(Enums.formatoSoapFromSpecifica.get(as.getFormatoSpecifica()));
  1550.                 ret.setTipoInterfaccia(iSoap);
  1551.                 ret.setInterfaccia(as.getByteWsdlLogicoErogatore());
  1552.                 break;
  1553.             default:
  1554.                 throw FaultCode.ERRORE_INTERNO
  1555.                         .toException("Tipologia interfaccia registro sconosciuta: " + as.getServiceBinding().name());
  1556.             }

  1558.             context.getLogger().info("Invocazione completata con successo");
  1559.             return ret;

  1561.         } catch (javax.ws.rs.WebApplicationException e) {
  1562.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1563.             throw e;
  1564.         } catch (Throwable e) {
  1565.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1566.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1567.         }
  1568.     }

  1570.     /**
  1571.     * Restituisce le informazioni ModI associate all'API
  1572.     *
  1573.     * Questa operazione consente di ottenere le informazioni ModI associato all'API identificata dal nome e dalla versione
  1574.     *
  1575.     */
  1576.     @Override
  1577.     public ApiModI getApiModI(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1578.         IContext context = this.getContext();
  1579.         try {
  1580.             context.getLogger().info("Invocazione in corso ...");     

  1582.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1583.             context.getLogger().debug("Autorizzazione completata con successo");     
  1584.                 
  1585.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1586.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1588.             if (as == null)
  1589.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1591.             ApiModI ret = ModiApiApiHelper.getApiModI(as, profilo, env);
  1592.             
  1593.             context.getLogger().info("Invocazione completata con successo");
  1594.             return ret;

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

  1608.     /**
  1609.      * Restituisce il nome del soggetto referente dell'api
  1610.      *
  1611.      * Questa operazione consente di ottenere il nome del soggetto referente
  1612.      * dell'API identificata dal nome e dalla versione
  1613.      *
  1614.      */
  1615.     @Override
  1616.     public ApiReferenteView getApiReferente(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1617.         IContext context = this.getContext();
  1618.         try {
  1619.             context.getLogger().info("Invocazione in corso ...");

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

  1624.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1625.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1627.             if (as == null)
  1628.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1630.             ApiReferenteView ret = new ApiReferenteView();
  1631.             ret.setProfilo(env.profilo);
  1632.             ret.setReferente(as.getSoggettoReferente().getNome());

  1634.             context.getLogger().info("Invocazione completata con successo");
  1635.             return ret;
  1636.         } catch (javax.ws.rs.WebApplicationException e) {
  1637.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1638.             throw e;
  1639.         } catch (Throwable e) {
  1640.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1641.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1642.         }
  1643.     }

  1645.     /**
  1646.      * Restituisce il dettaglio di una risorsa di una API
  1647.      *
  1648.      * Questa operazione consente di ottenere il dettaglio di una risorsa della API
  1649.      * identificata dal nome e dalla versione
  1650.      *
  1651.      */
  1652.     @Override
  1653.     public ApiRisorsa getApiRisorsa(String nome, Integer versione, String nomeRisorsa, ProfiloEnum profilo,
  1654.             String soggetto) {
  1655.         IContext context = this.getContext();
  1656.         try {
  1657.             context.getLogger().info("Invocazione in corso ...");

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

  1662.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1663.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1665.             if (as == null)
  1666.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1668.             Resource res = as.getResourceList().stream().filter(r -> nomeRisorsa.equals(r.getNome()))
  1669.                     .findFirst().orElse(null);

  1671.             if (res == null)
  1672.                 throw FaultCode.NOT_FOUND
  1673.                         .toException("Nessuna risorsa con nome " + nomeRisorsa + " è registrata per la Api indicata");


  1676.             ApiRisorsa ret = ApiApiHelper.risorsaRegistroToApi(res);

  1678.             ApiApiHelper.populateApiRisorsaWithProtocolInfo(as, res, env, profilo, ret);

  1680.             context.getLogger().info("Invocazione completata con successo");
  1681.             return ret;

  1683.         } catch (javax.ws.rs.WebApplicationException e) {
  1684.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1685.             throw e;
  1686.         } catch (Throwable e) {
  1687.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1688.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1689.         }
  1690.     }

  1692.     /**
  1693.      * Restituisce il dettaglio di un servizio di una API
  1694.      *
  1695.      * Questa operazione consente di ottenere il dettaglio di un servizio della API
  1696.      * identificata dal nome e dalla versione
  1697.      *
  1698.      */
  1699.     @Override
  1700.     public ApiServizio getApiServizio(String nome, Integer versione, String nomeServizio, ProfiloEnum profilo,
  1701.             String soggetto) {
  1702.         IContext context = this.getContext();
  1703.         try {
  1704.             context.getLogger().info("Invocazione in corso ...");

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

  1709.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1710.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1712.             if (as == null)
  1713.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1715.             ApiServizio ret = as.getPortTypeList().stream().filter(p -> nomeServizio.equals(p.getNome()))
  1716.                     .map(p -> ApiApiHelper.servizioRegistroToApi(p)).findFirst().orElse(null);

  1718.             if (ret == null)
  1719.                 throw FaultCode.NOT_FOUND.toException("Nessun Servizio con nome: " + nomeServizio);

  1721.             context.getLogger().info("Invocazione completata con successo");
  1722.             return ret;

  1724.         } catch (javax.ws.rs.WebApplicationException e) {
  1725.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1726.             throw e;
  1727.         } catch (Throwable e) {
  1728.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1729.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1730.         }
  1731.     }

  1733.     /**
  1734.      * Restituisce i tags associati all'API
  1735.      *
  1736.      * Questa operazione consente di ottenere i tags associati all'API identificata dal nome e dalla versione
  1737.      *
  1738.      */
  1739.     @Override
  1740.     public ApiTags getApiTags(String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1741.         IContext context = this.getContext();
  1742.         try {
  1743.             context.getLogger().info("Invocazione in corso ...");

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

  1748.             ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1749.             AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1751.             if (as == null)
  1752.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1754.             ApiTags ret = new ApiTags();
  1755.             if(as.getGruppi()!=null && as.getGruppi().getGruppoList()!=null && !as.getGruppi().getGruppoList().isEmpty()) {
  1756.                 for (GruppoAccordo tag : as.getGruppi().getGruppoList()) {
  1757.                     ret.addTagsItem(tag.getNome());
  1758.                 }
  1759.             }
  1760.             
  1761.             context.getLogger().info("Invocazione completata con successo");
  1762.             return ret;

  1764.         } catch (javax.ws.rs.WebApplicationException e) {
  1765.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1766.             throw e;
  1767.         } catch (Throwable e) {
  1768.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1769.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1770.         }
  1771.     }

  1773.     
  1774.     /**
  1775.      * Modifica i dati di un allegato di una API
  1776.      *
  1777.      * Questa operazione consente di aggiornare i dettagli di un allegato della API
  1778.      * identificata dal nome e dalla versione
  1779.      *
  1780.      */
  1781.     @Override
  1782.     public void updateApiAllegato(ApiAllegato body, String nome, Integer versione, String nomeAllegato,
  1783.             ProfiloEnum profilo, String soggetto) {
  1784.         IContext context = this.getContext();
  1785.         try {
  1786.             context.getLogger().info("Invocazione in corso ...");

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

  1791.             if (body == null)
  1792.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  1794.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1795.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1797.             if (as == null)
  1798.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1800.             final Documento oldDoc = BaseHelper.supplyOrNotFound(() -> env.archiviCore.getDocumento(nomeAllegato, null, null,
  1801.                     as.getId(), false, ProprietariDocumento.accordoServizio),
  1802.                     "Allegato con nome " + nomeAllegato + " per la API scelta.");

  1804.             final Documento newDoc = ApiApiHelper.apiAllegatoToDocumento(body, as, env);
  1805.             newDoc.setId(oldDoc.getId());

  1807.             if (!newDoc.getRuolo().equals(oldDoc.getRuolo()))
  1808.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non puoi modificare il ruolo di un allegato");

  1810.             SerialiableFormFile filewrap = new SerialiableFormFile(newDoc.getFile(), newDoc.getByteContenuto());

  1812.             env.requestWrapper.overrideParameter(AccordiServizioParteComuneCostanti.PARAMETRO_APC_ALLEGATI_RUOLO,
  1813.                     newDoc.getRuolo());

  1815.             ArchiviHelper archiviHelper = new ArchiviHelper(env.stationCore, env.requestWrapper, env.pd,
  1816.                     env.requestWrapper.getSession());

  1818.             if (!archiviHelper.accordiAllegatiCheckData(TipoOperazione.CHANGE, filewrap, newDoc,
  1819.                     ProprietariDocumento.accordoServizio, env.protocolFactory)) {
  1820.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  1821.             }

  1823.             AccordiServizioParteComuneUtilities.updateAccordoServizioParteComuneAllegati(as, oldDoc, newDoc);

  1825.             env.apcCore.performUpdateOperation(env.userLogin, false, as);

  1827.             context.getLogger().info("Invocazione completata con successo");
  1828.         } catch (javax.ws.rs.WebApplicationException e) {
  1829.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1830.             throw e;
  1831.         } catch (Throwable e) {
  1832.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1833.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1834.         }
  1835.     }

  1837.     /**
  1838.      * Modifica i dati di un'azione nel servizio di una API
  1839.      *
  1840.      * Questa operazione consente di aggiornare i dettagli di un'azione della API
  1841.      * identificata dal nome e dalla versione
  1842.      *
  1843.      */
  1844.     @Override
  1845.     public void updateApiAzione(ApiAzione body, String nome, Integer versione, String nomeServizio, String nomeAzione,
  1846.             ProfiloEnum profilo, String soggetto) {
  1847.         IContext context = this.getContext();
  1848.         try {
  1849.             context.getLogger().info("Invocazione in corso ...");

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

  1854.             if (body == null)
  1855.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  1857.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1858.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  1860.             if (as == null)
  1861.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1863.             final PortType pt = as.getPortTypeList().stream().filter(p -> nomeServizio.equals(p.getNome())).findFirst()
  1864.                     .orElse(null);

  1866.             if (pt == null)
  1867.                 throw FaultCode.NOT_FOUND.toException("Nessun Servizio con nome: " + nomeServizio);

  1869.             final Operation oldOp = BaseHelper.findAndRemoveFirst(pt.getAzioneList(),
  1870.                     (op -> nomeAzione.equals(op.getNome())));

  1872.             if (oldOp == null)
  1873.                 throw FaultCode.NOT_FOUND
  1874.                         .toException("Nessuna Azione con nome: " + nomeAzione + " associata al servizio " + nomeServizio);

  1876.             if (!nomeAzione.equals(oldOp.getNome())) {
  1877.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non puoi modificare il nome dell'azione");
  1878.             }

  1880.             ApiApiHelper.updateOperation(body, pt, oldOp);
  1881.             final Operation newOp = oldOp;
  1882.             
  1883.             ProfiloCollaborazioneEnum profiloBody = body.getProfiloCollaborazione()!=null ? body.getProfiloCollaborazione() : ProfiloCollaborazioneEnum.SINCRONO;
  1884.             
  1885.             ProtocolProperties protocolProperties = null;
  1886.             if(profilo != null) {
  1887.                 protocolProperties = ApiApiHelper.getProtocolProperties(body, profilo, as, newOp, env);
  1888.     
  1889.                 if(protocolProperties != null) {
  1890.                     newOp.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.CHANGE, null));
  1891.                 }
  1892.             }

  1894.             if (! env.apcHelper.accordiPorttypeOperationCheckData(
  1895.                     TipoOperazione.CHANGE,
  1896.                     as.getId().toString(),
  1897.                     nomeServizio,
  1898.                     newOp.getNome(),
  1899.                     newOp.getProfAzione(),
  1900.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getFiltroDuplicati()),
  1901.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getConfermaRicezione()),
  1902.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getIdCollaborazione()),
  1903.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getIdRiferimentoRichiesta()),
  1904.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newOp.getConsegnaInOrdine()),
  1905.                     newOp.getScadenza() != null ? newOp.getScadenza() : "", // Scadenza operazione
  1906.                     "-", // Servizio Correlato
  1907.                     "-", // Azione Correlata
  1908.                     Enums.profiloCollaborazioneFromApiEnum.get(profiloBody).toString(), "0", // styleOp
  1909.                     "", // soapActionOp,
  1910.                     "literal", // useOp,
  1911.                     null, // opTypeOp,
  1912.                     "" // nsWSDLOp
  1913.             )) {
  1914.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  1915.             }

  1917.             IDPortType idPT = new IDPortType();
  1918.             idPT.setNome(pt.getNome());
  1919.             idPT.setIdAccordo(IDAccordoFactory.getInstance().getIDAccordoFromAccordo(as));
  1920.             IDPortTypeAzione idAccordoAzione = new IDPortTypeAzione();
  1921.             idAccordoAzione.setNome(oldOp.getNome());
  1922.             idAccordoAzione.setIdPortType(idPT);
  1923.             
  1924.             ApiApiHelper.validateProperties(env, protocolProperties, idAccordoAzione, ConsoleOperationType.CHANGE);
  1925.             
  1926.             // Dopo aver fatto i controlli sui dati aggiungo la nuova azione
  1927.             pt.addAzione(newOp);

  1929.             AccordiServizioParteComuneUtilities.createPortTypeOperation(env.apcCore.isEnableAutoMappingWsdlIntoAccordo(),
  1930.                     env.apcCore, env.apcHelper, as, pt, env.userLogin);

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

  1934.         } catch (javax.ws.rs.WebApplicationException e) {
  1935.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  1936.             throw e;
  1937.         } catch (Throwable e) {
  1938.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  1939.             throw FaultCode.ERRORE_INTERNO.toException(e);
  1940.         }
  1941.     }

  1943.     /**
  1944.      * Consente di modificare il canale associato all'API
  1945.      *
  1946.      * Questa operazione consente di aggiornare il canale associato all'API identificata dal nome e dalla versione
  1947.      *
  1948.      */
  1949.     @Override
  1950.     public void updateApiCanale(ConfigurazioneApiCanale body, String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  1951.         IContext context = this.getContext();
  1952.         try {
  1953.             context.getLogger().info("Invocazione in corso ...");     

  1955.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  1956.             context.getLogger().debug("Autorizzazione completata con successo");     
  1957.                         
  1958.             if (body == null)
  1959.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");
  1960.             
  1961.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  1962.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);
  1963.             
  1964.             if (as == null)
  1965.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  1967.             
  1968.             final IDAccordo oldIdAccordo = env.idAccordoFactory.getIDAccordoFromAccordo(as);

  1970.             if(!env.gestioneCanali) {
  1971.                 throw new Exception("Gestione dei canali non abilitata");
  1972.             }
  1973.             
  1974.             if(ConfigurazioneCanaleEnum.RIDEFINITO.equals(body.getConfigurazione())){
  1975.                 if(body.getCanale()==null || "".equals(body.getCanale())) {
  1976.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un canale");
  1977.                 }
  1978.                 if(!env.canali.contains(body.getCanale())) {
  1979.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il canale fornito '" + body.getCanale() + "' non è presente nel registro");
  1980.                 }
  1981.                 as.setCanale(body.getCanale());
  1982.             }
  1983.             else {
  1984.                 as.setCanale(null);
  1985.             }

  1987.             boolean validazioneDocumenti = ServerProperties.getInstance().isValidazioneDocumenti();

  1989.             BinaryParameter wsdlserv = new BinaryParameter();
  1990.             wsdlserv.setValue(as.getByteWsdlLogicoErogatore());

  1992.             BinaryParameter wsdlconc = new BinaryParameter();
  1993.             wsdlconc.setValue(as.getByteWsdlConcettuale());

  1995.             BinaryParameter wsdldef = new BinaryParameter();
  1996.             wsdldef.setValue(as.getByteWsdlDefinitorio());

  1998.             /*
  1999.              * boolean visibilitaAccordoCooperazione=false;
  2000.              * if("-".equals(this.accordoCooperazioneId)==false &&
  2001.              * "".equals(this.accordoCooperazioneId)==false &&
  2002.              * this.accordoCooperazioneId!=null){ AccordoCooperazione ac =
  2003.              * acCore.getAccordoCooperazione(Long.parseLong(this.accordoCooperazioneId));
  2004.              * visibilitaAccordoCooperazione=ac.getPrivato()!=null && ac.getPrivato(); }
  2005.              */

  2007.             StringBuilder bfTags = new StringBuilder();
  2008.             if(as.getGruppi()!=null && as.getGruppi().getGruppoList()!=null && !as.getGruppi().getGruppoList().isEmpty()) {
  2009.                 for (GruppoAccordo tag : as.getGruppi().getGruppoList()) {
  2010.                     if(bfTags.length()>0) {
  2011.                         bfTags.append(",");
  2012.                     }
  2013.                     bfTags.append(tag.getNome());
  2014.                 }
  2015.             }
  2016.             
  2017.             boolean gestioneCanaliEnabled = env.gestioneCanali;
  2018.             String canale = as.getCanale();
  2019.             String canaleStato = null;
  2020.             if(canale == null) {
  2021.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  2022.             } else {
  2023.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  2024.             }
  2025.             
  2026.             if (!env.apcHelper.accordiCheckData(TipoOperazione.CHANGE, as.getNome(), as.getDescrizione(),
  2027.                     as.getProfiloCollaborazione().toString(), Helper.toBinaryParameter(as.getByteWsdlDefinitorio()),
  2028.                     Helper.toBinaryParameter(as.getByteWsdlConcettuale()),
  2029.                     Helper.toBinaryParameter(as.getByteWsdlLogicoErogatore()),
  2030.                     Helper.toBinaryParameter(as.getByteWsdlLogicoFruitore()),
  2031.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getFiltroDuplicati()),
  2032.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConfermaRicezione()),
  2033.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdCollaborazione()),
  2034.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdRiferimentoRichiesta()),
  2035.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConsegnaInOrdine()),
  2036.                     as.getScadenza() == null ? "" : as.getScadenza(), as.getId().toString(), as.getSoggettoReferente().getNome(),
  2037.                     as.getVersione().toString(), null, // AccordoCooperazioneID
  2038.                     false, // privato false, null,
  2039.                     false, // visibilitaAccordoCooperazione
  2040.                     oldIdAccordo, // idAccordoOld
  2041.                     null, // wsblconc
  2042.                     null, // wsblserv
  2043.                     null, // wsblservrorr
  2044.                     validazioneDocumenti, env.tipo_protocollo, null, // backToStato
  2045.                     env.apcCore.toMessageServiceBinding(as.getServiceBinding()), null, // MessageType
  2046.                     Enums.interfaceTypeFromFormatoSpecifica.get(as.getFormatoSpecifica()), env.gestisciSoggettoReferente,
  2047.                     bfTags.toString(),
  2048.                     canaleStato, canale, gestioneCanaliEnabled)) {

  2050.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2051.             }

  2053.             // Il profilo di collaborazione di base è Sincrono.
  2054.             // Quindi Nella AccordiServizioPArteComuneChange così come nella Add possiamo
  2055.             // assumerlo costante.
  2056.             // Sono i Servizi e le Azioni ad avere un profilo di collaborazione

  2058.             as.setOldIDAccordoForUpdate(oldIdAccordo);
  2059.             List<Object> operazioniList = new ArrayList<>(Arrays.asList(as));

  2061.             // Questa roba non serve qui perchè la updateDescrizione non cambia il nome e
  2062.             // quindi nemmeno l'ID.
  2063.             IDAccordo idNEW = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2064.             if (idNEW.equals(oldIdAccordo) == false) {
  2065.                 AccordiServizioParteComuneUtilities.findOggettiDaAggiornare(oldIdAccordo, as, env.apcCore, operazioniList);
  2066.             }

  2068.             env.apcCore.performUpdateOperation(env.userLogin, false, operazioniList.toArray());

  2070.             context.getLogger().info("Invocazione completata con successo");
  2071.         }
  2072.         catch(javax.ws.rs.WebApplicationException e) {
  2073.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2074.             throw e;
  2075.         }
  2076.         catch(Throwable e) {
  2077.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2078.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2079.         }
  2080.     }

  2082.     /**
  2083.      * Consente di modificare la descrizione di una API
  2084.      *
  2085.      * Questa operazione consente di aggiornare la descrizione di una API
  2086.      * identificata dal nome e dalla versione
  2087.      *
  2088.      */
  2089.     @Override
  2090.     public void updateApiDescrizione(ApiDescrizione body, String nome, Integer versione, ProfiloEnum profilo,
  2091.             String soggetto) {
  2092.         IContext context = this.getContext();
  2093.         try {
  2094.             context.getLogger().info("Invocazione in corso ...");

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

  2099.             if (body == null)
  2100.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  2102.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2103.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);
  2104.             
  2105.             if (as == null)
  2106.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  2108.             final IDAccordo oldIdAccordo = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2109.             
  2110.             as.setDescrizione(body.getDescrizione());

  2112.             boolean validazioneDocumenti = ServerProperties.getInstance().isValidazioneDocumenti();

  2114.             BinaryParameter wsdlserv = new BinaryParameter();
  2115.             wsdlserv.setValue(as.getByteWsdlLogicoErogatore());

  2117.             BinaryParameter wsdlconc = new BinaryParameter();
  2118.             wsdlconc.setValue(as.getByteWsdlConcettuale());

  2120.             BinaryParameter wsdldef = new BinaryParameter();
  2121.             wsdldef.setValue(as.getByteWsdlDefinitorio());

  2123.             /*
  2124.              * boolean visibilitaAccordoCooperazione=false;
  2125.              * if("-".equals(this.accordoCooperazioneId)==false &&
  2126.              * "".equals(this.accordoCooperazioneId)==false &&
  2127.              * this.accordoCooperazioneId!=null){ AccordoCooperazione ac =
  2128.              * acCore.getAccordoCooperazione(Long.parseLong(this.accordoCooperazioneId));
  2129.              * visibilitaAccordoCooperazione=ac.getPrivato()!=null && ac.getPrivato(); }
  2130.              */

  2132.             StringBuilder bfTags = new StringBuilder();
  2133.             if(as.getGruppi()!=null && as.getGruppi().getGruppoList()!=null && !as.getGruppi().getGruppoList().isEmpty()) {
  2134.                 for (GruppoAccordo tag : as.getGruppi().getGruppoList()) {
  2135.                     if(bfTags.length()>0) {
  2136.                         bfTags.append(",");
  2137.                     }
  2138.                     bfTags.append(tag.getNome());
  2139.                 }
  2140.             }
  2141.             
  2142.             boolean gestioneCanaliEnabled = env.gestioneCanali;
  2143.             String canale = as.getCanale();
  2144.             String canaleStato = null;
  2145.             if(canale == null) {
  2146.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  2147.             } else {
  2148.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  2149.             }
  2150.             
  2151.             if (!env.apcHelper.accordiCheckData(TipoOperazione.CHANGE, as.getNome(), as.getDescrizione(),
  2152.                     as.getProfiloCollaborazione().toString(), Helper.toBinaryParameter(as.getByteWsdlDefinitorio()),
  2153.                     Helper.toBinaryParameter(as.getByteWsdlConcettuale()),
  2154.                     Helper.toBinaryParameter(as.getByteWsdlLogicoErogatore()),
  2155.                     Helper.toBinaryParameter(as.getByteWsdlLogicoFruitore()),
  2156.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getFiltroDuplicati()),
  2157.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConfermaRicezione()),
  2158.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdCollaborazione()),
  2159.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdRiferimentoRichiesta()),
  2160.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConsegnaInOrdine()),
  2161.                     as.getScadenza() == null ? "" : as.getScadenza(), as.getId().toString(), as.getSoggettoReferente().getNome(),
  2162.                     as.getVersione().toString(), null, // AccordoCooperazioneID
  2163.                     false, // privato false, null,
  2164.                     false, // visibilitaAccordoCooperazione
  2165.                     oldIdAccordo, // idAccordoOld
  2166.                     null, // wsblconc
  2167.                     null, // wsblserv
  2168.                     null, // wsblservrorr
  2169.                     validazioneDocumenti, env.tipo_protocollo, null, // backToStato
  2170.                     env.apcCore.toMessageServiceBinding(as.getServiceBinding()), null, // MessageType
  2171.                     Enums.interfaceTypeFromFormatoSpecifica.get(as.getFormatoSpecifica()), env.gestisciSoggettoReferente,
  2172.                     bfTags.toString(),
  2173.                     canaleStato, canale, gestioneCanaliEnabled)) {

  2175.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2176.             }

  2178.             // Il profilo di collaborazione di base è Sincrono.
  2179.             // Quindi Nella AccordiServizioPArteComuneChange così come nella Add possiamo
  2180.             // assumerlo costante.
  2181.             // Sono i Servizi e le Azioni ad avere un profilo di collaborazione

  2183.             as.setOldIDAccordoForUpdate(oldIdAccordo);
  2184.             List<Object> operazioniList = new ArrayList<>(Arrays.asList(as));

  2186.             // Questa roba non serve qui perchè la updateDescrizione non cambia il nome e
  2187.             // quindi nemmeno l'ID.
  2188.             IDAccordo idNEW = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2189.             if (idNEW.equals(oldIdAccordo) == false) {
  2190.                 AccordiServizioParteComuneUtilities.findOggettiDaAggiornare(oldIdAccordo, as, env.apcCore, operazioniList);
  2191.             }

  2193.             env.apcCore.performUpdateOperation(env.userLogin, false, operazioniList.toArray());

  2195.             context.getLogger().info("Invocazione completata con successo");
  2196.         } catch (javax.ws.rs.WebApplicationException e) {
  2197.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  2198.             throw e;
  2199.         } catch (Throwable e) {
  2200.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  2201.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2202.         }
  2203.     }

  2205.     /**
  2206.      * Consente di modificare le informazioni generali di una API
  2207.      *
  2208.      * Questa operazione consente di aggiornare le informazioni generali di una API
  2209.      * identificata dal nome e dalla versione
  2210.      *
  2211.      */
  2212.     @Override
  2213.     public void updateApiInformazioniGenerali(ApiInformazioniGenerali body, String nome, Integer versione,
  2214.             ProfiloEnum profilo, String soggetto) {
  2215.         IContext context = this.getContext();
  2216.         try {
  2217.             context.getLogger().info("Invocazione in corso ...");

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

  2222.             BaseHelper.throwIfNull(body);

  2224.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2225.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  2227.             if (as == null)
  2228.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  2230.             final IDAccordo oldIdAccordo = env.idAccordoFactory.getIDAccordoFromAccordo(as);

  2232.             as.setNome(body.getNome());
  2233.             as.setVersione(body.getVersione());

  2235.             boolean validazioneDocumenti = ServerProperties.getInstance().isValidazioneDocumenti();

  2237.             /*
  2238.              * boolean visibilitaAccordoCooperazione=false;
  2239.              * if("-".equals(this.accordoCooperazioneId)==false &&
  2240.              * "".equals(this.accordoCooperazioneId)==false &&
  2241.              * this.accordoCooperazioneId!=null){ AccordoCooperazione ac =
  2242.              * acCore.getAccordoCooperazione(Long.parseLong(this.accordoCooperazioneId));
  2243.              * visibilitaAccordoCooperazione=ac.getPrivato()!=null && ac.getPrivato(); }
  2244.              */

  2246.             StringBuilder bfTags = new StringBuilder();
  2247.             if(as.getGruppi()!=null && as.getGruppi().getGruppoList()!=null && !as.getGruppi().getGruppoList().isEmpty()) {
  2248.                 for (GruppoAccordo tag : as.getGruppi().getGruppoList()) {
  2249.                     if(bfTags.length()>0) {
  2250.                         bfTags.append(",");
  2251.                     }
  2252.                     bfTags.append(tag.getNome());
  2253.                 }
  2254.             }
  2255.             
  2256.             boolean gestioneCanaliEnabled = env.gestioneCanali;
  2257.             String canale = as.getCanale();
  2258.             String canaleStato = null;
  2259.             if(canale == null) {
  2260.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  2261.             } else {
  2262.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  2263.             }
  2264.             
  2265.             if (!env.apcHelper.accordiCheckData(TipoOperazione.CHANGE, as.getNome(), as.getDescrizione(),
  2266.                     as.getProfiloCollaborazione().toString(), Helper.toBinaryParameter(as.getByteWsdlDefinitorio()),
  2267.                     Helper.toBinaryParameter(as.getByteWsdlConcettuale()),
  2268.                     Helper.toBinaryParameter(as.getByteWsdlLogicoErogatore()),
  2269.                     Helper.toBinaryParameter(as.getByteWsdlLogicoFruitore()),
  2270.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getFiltroDuplicati()),
  2271.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConfermaRicezione()),
  2272.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdCollaborazione()),
  2273.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdRiferimentoRichiesta()),
  2274.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConsegnaInOrdine()),
  2275.                     as.getScadenza() == null ? "" : as.getScadenza(), as.getId().toString(), as.getSoggettoReferente().getNome(),
  2276.                     as.getVersione().toString(), null, // AccordoCooperazioneID
  2277.                     false, // privato false, null,
  2278.                     false, // visibilitaAccordoCooperazione
  2279.                     oldIdAccordo, // idAccordoOld
  2280.                     null, // wsblconc
  2281.                     null, // wsblserv
  2282.                     null, // wsblservrorr
  2283.                     validazioneDocumenti, env.tipo_protocollo, null, // backToStato
  2284.                     env.apcCore.toMessageServiceBinding(as.getServiceBinding()), null, // MessageType
  2285.                     Enums.interfaceTypeFromFormatoSpecifica.get(as.getFormatoSpecifica()), env.gestisciSoggettoReferente,
  2286.                     bfTags.toString(),
  2287.                     canaleStato, canale, gestioneCanaliEnabled)) {

  2289.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2290.             }

  2292.             as.setOldIDAccordoForUpdate(oldIdAccordo);
  2293.             List<Object> operazioniList = new ArrayList<>(Arrays.asList(as));

  2295.             IDAccordo idNEW = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2296.             if (idNEW.equals(oldIdAccordo) == false) {
  2297.                 AccordiServizioParteComuneUtilities.findOggettiDaAggiornare(oldIdAccordo, as, env.apcCore, operazioniList);
  2298.             }

  2300.             env.apcCore.performUpdateOperation(env.userLogin, false, operazioniList.toArray());
  2301.             context.getLogger().info("Invocazione completata con successo");
  2302.         } catch (javax.ws.rs.WebApplicationException e) {
  2303.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  2304.             throw e;
  2305.         } catch (Throwable e) {
  2306.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  2307.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2308.         }
  2309.     }

  2311.     /**
  2312.      * Consente di modificare l'interfaccia di una API
  2313.      *
  2314.      * Questa operazione consente di aggiornare l'interfaccia di una API
  2315.      * identificata dal nome e dalla versione
  2316.      *
  2317.      */
  2318.     @Override
  2319.     public void updateApiInterfaccia(ApiInterfaccia body, String nome, Integer versione, ProfiloEnum profilo,
  2320.             String soggetto) {
  2321.         IContext context = this.getContext();
  2322.         try {
  2323.             context.getLogger().info("Invocazione in corso ...");

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

  2328.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2329.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  2331.             if (as == null)
  2332.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  2334.             final String tipoWsdl = as.getServiceBinding() == ServiceBinding.REST
  2335.                     ? AccordiServizioParteComuneCostanti.PARAMETRO_APC_WSDL_CONCETTUALE
  2336.                     : AccordiServizioParteComuneCostanti.PARAMETRO_APC_WSDL_EROGATORE;

  2338.             final String wsdl = new String(body.getInterfaccia());

  2340.             ServerProperties serverProperties = ServerProperties.getInstance();
  2341.             final boolean validazioneDocumenti = serverProperties.isValidazioneDocumenti();

  2343.             if (!env.apcHelper.accordiWSDLCheckData(env.pd, tipoWsdl, wsdl, as, validazioneDocumenti, env.tipo_protocollo)) {
  2344.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2345.             }

  2347.             final boolean facilityUnicoWSDL_interfacciaStandard = as.getServiceBinding() == ServiceBinding.SOAP;

  2349.             ServerProperties properties = ServerProperties.getInstance();

  2351.             boolean aggiornaEsistenti = serverProperties.isUpdateInterfacciaApiUpdateIfExists();
  2352.             boolean eliminaNonPresentiNuovaInterfaccia = serverProperties.isUpdateInterfacciaApiDeleteIfNotFound();
  2353.             List<IDResource> risorseEliminate = new ArrayList<IDResource>();
  2354.             List<IDPortType> portTypeEliminati = new ArrayList<IDPortType>();
  2355.             List<IDPortTypeAzione> operationEliminate = new ArrayList<IDPortTypeAzione>();
  2356.             
  2357.             AccordiServizioParteComuneUtilities.updateInterfacciaAccordoServizioParteComune(tipoWsdl, wsdl, as,
  2358.                     properties.isEnabledAutoMapping(), properties.isValidazioneDocumenti(),
  2359.                     properties.isEnabledAutoMappingEstraiXsdSchemiFromWsdlTypes(), facilityUnicoWSDL_interfacciaStandard,
  2360.                     env.tipo_protocollo, env.apcCore,
  2361.                     aggiornaEsistenti, eliminaNonPresentiNuovaInterfaccia,
  2362.                     risorseEliminate, portTypeEliminati, operationEliminate);

  2364.             // effettuo le operazioni
  2365.             env.apcCore.performUpdateOperation(env.userLogin, false, as);

  2367.             context.getLogger().info("Invocazione completata con successo");
  2368.         } catch (javax.ws.rs.WebApplicationException e) {
  2369.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  2370.             throw e;
  2371.         } catch (Throwable e) {
  2372.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  2373.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2374.         }
  2375.     }

  2377.     /**
  2378.      * Consente di modificare le informazioni ModI associate all'API
  2379.      *
  2380.      * Questa operazione consente di aggiornare le informazioni ModI associate all'API identificata dal nome e dalla versione
  2381.      *
  2382.     */
  2383.     @Override
  2384.     public void updateApiModI(ApiModI body, String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  2385.         IContext context = this.getContext();
  2386.         try {
  2387.             context.getLogger().info("Invocazione in corso ...");     

  2389.             AuthorizationManager.authorize(context, getAuthorizationConfig());
  2390.             context.getLogger().debug("Autorizzazione completata con successo");     
  2391.                 
  2392.             if (body == null)
  2393.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  2395.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2396.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  2398.             if (as == null)
  2399.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  2401.             ProtocolProperties updateModiProtocolProperties = ModiApiApiHelper.updateModiProtocolProperties(as, profilo, body);
  2402.             
  2403.             IDAccordo idAccordoFromAccordo = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2404.             ApiApiHelper.validateProperties(env, updateModiProtocolProperties, idAccordoFromAccordo, ConsoleOperationType.CHANGE);
  2405.             
  2406.             if(updateModiProtocolProperties != null) {
  2407.                 as.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(updateModiProtocolProperties, ConsoleOperationType.ADD, null));
  2408.             }

  2410.             env.apcCore.performUpdateOperation(env.userLogin, false, as);

  2412.             context.getLogger().info("Invocazione completata con successo");
  2413.         }
  2414.         catch(javax.ws.rs.WebApplicationException e) {
  2415.             context.getLogger().error("Invocazione terminata con errore '4xx': %s",e, e.getMessage());
  2416.             throw e;
  2417.         }
  2418.         catch(Throwable e) {
  2419.             context.getLogger().error("Invocazione terminata con errore: %s",e, e.getMessage());
  2420.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2421.         }
  2422.     }

  2424.     /**
  2425.      * Modifica i dati di una risorsa di una API
  2426.      *
  2427.      * Questa operazione consente di aggiornare i dettagli di una risorsa della API
  2428.      * identificata dal nome e dalla versione
  2429.      *
  2430.      */
  2431.     @Override
  2432.     public void updateApiRisorsa(ApiRisorsa body, String nome, Integer versione, String nomeRisorsa, ProfiloEnum profilo,
  2433.             String soggetto) {
  2434.         IContext context = this.getContext();
  2435.         try {
  2436.             context.getLogger().info("Invocazione in corso ...");

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

  2441.             if (body == null)
  2442.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  2444.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2445.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  2447.             if (as == null)
  2448.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  2450.             Resource oldResource = BaseHelper.findAndRemoveFirst(as.getResourceList(), r -> nomeRisorsa.equals(r.getNome()));

  2452.             if (oldResource == null)
  2453.                 throw FaultCode.NOT_FOUND.toException("Nessuna risorsa trovata con nome " + nomeRisorsa);

  2455.             final String oldPath = oldResource.getPath();
  2456.             final String oldHttpMethod = oldResource.getMethodRawEnumValue();
  2457.             final String oldNomeRisorsaGenerato = oldHttpMethod != null
  2458.                     ? APIUtils.normalizeResourceName(HttpMethod.toEnumConstant(oldHttpMethod), oldPath)
  2459.                     : null;

  2461.             ApiApiHelper.updateRisorsa(body, oldResource);
  2462.             final Resource newRes = oldResource;

  2464.             ProtocolProperties protocolProperties = null;
  2465.             if(profilo != null) {
  2466.                 protocolProperties = ApiApiHelper.getProtocolProperties(body, profilo, newRes, env);
  2467.     
  2468.                 if(protocolProperties != null) {
  2469.                     newRes.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, ConsoleOperationType.CHANGE, null));
  2470.                 }
  2471.             }

  2473.             if (!env.apcHelper.accordiResourceCheckData(TipoOperazione.CHANGE, as.getId().toString(),
  2474.                     body.getNome() != null ? body.getNome() : "", newRes.getNome(), newRes.getPath(), newRes.getMethodRawEnumValue(),
  2475.                     newRes.getDescrizione(), env.apcCore.toMessageMessageType(newRes.getMessageType()), nomeRisorsa,
  2476.                     oldNomeRisorsaGenerato, oldPath, oldHttpMethod,
  2477.                     AccordiServizioParteComuneCostanti.INFORMAZIONI_PROTOCOLLO_MODALITA_RIDEFINITO,
  2478.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getFiltroDuplicati()),
  2479.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getConfermaRicezione()), // confricaz,
  2480.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getIdCollaborazione()),
  2481.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getIdRiferimentoRichiesta()),
  2482.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newRes.getConsegnaInOrdine()), // consordaz,
  2483.                     newRes.getScadenza() != null ? newRes.getScadenza() : "")) {
  2484.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2485.             }
  2486.             
  2487.             IDResource idResource = new IDResource();
  2488.             idResource.setNome(oldResource.getNome());
  2489.             idResource.setIdAccordo(IDAccordoFactory.getInstance().getIDAccordoFromAccordo(as));
  2490.             
  2491.             ApiApiHelper.validateProperties(env, protocolProperties, idResource, newRes.getMethod()!=null ? newRes.getMethod().toString() : null, newRes.getPath(), ConsoleOperationType.ADD);
  2492.             

  2494.             as.addResource(newRes);

  2496.             AccordiServizioParteComuneUtilities.createResource(env.apcCore.isEnableAutoMappingWsdlIntoAccordo(), env.apcCore,
  2497.                     env.apcHelper, as, env.userLogin);

  2499.             context.getLogger().info("Invocazione completata con successo");
  2500.         } catch (javax.ws.rs.WebApplicationException e) {
  2501.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  2502.             throw e;
  2503.         } catch (Throwable e) {
  2504.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  2505.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2506.         }
  2507.     }

  2509.     /**
  2510.      * Modifica i dati di un servizio di una API
  2511.      *
  2512.      * Questa operazione consente di aggiornare i dettagli di un servizio della API
  2513.      * identificata dal nome e dalla versione
  2514.      *
  2515.      */
  2516.     @Override
  2517.     public void updateApiServizio(ApiServizio body, String nome, Integer versione, String nomeServizio,
  2518.             ProfiloEnum profilo, String soggetto) {
  2519.         IContext context = this.getContext();
  2520.         try {
  2521.             context.getLogger().info("Invocazione in corso ...");

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

  2526.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2527.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);

  2529.             if (as == null)
  2530.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);

  2532.             final PortType oldPt = BaseHelper.findAndRemoveFirst(as.getPortTypeList(),
  2533.                     (p -> nomeServizio.equals(p.getNome())));

  2535.             if (oldPt == null)
  2536.                 throw FaultCode.NOT_FOUND.toException("Nessun Servizio registrato con nome: " + nomeServizio);

  2538.             ApiApiHelper.updatePortType(body, oldPt, env);
  2539.             final PortType newPt = oldPt;

  2541.             if (!env.apcHelper.accordiPorttypeCheckData(TipoOperazione.CHANGE, as.getId().toString(), newPt.getNome(),
  2542.                     newPt.getDescrizione(), AccordiServizioParteComuneCostanti.INFORMAZIONI_PROTOCOLLO_MODALITA_RIDEFINITO,
  2543.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPt.getFiltroDuplicati()),
  2544.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPt.getConfermaRicezione()),
  2545.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPt.getIdCollaborazione()),
  2546.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPt.getIdRiferimentoRichiesta()),
  2547.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(newPt.getConsegnaInOrdine()),
  2548.                     newPt.getScadenza() != null ? newPt.getScadenza() : "")) {
  2549.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2550.             }

  2552.             as.addPortType(newPt);

  2554.             env.apcCore.performUpdateOperation(env.userLogin, false, as);

  2556.             context.getLogger().info("Invocazione completata con successo");
  2557.         } catch (javax.ws.rs.WebApplicationException e) {
  2558.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  2559.             throw e;
  2560.         } catch (Throwable e) {
  2561.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  2562.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2563.         }
  2564.     }
  2565.     
  2566.     /**
  2567.      * Consente di modificare i tags associati all'API
  2568.      *
  2569.      * Questa operazione consente di aggiornare i tags associati all'API identificata dal nome e dalla versione
  2570.      *
  2571.      */
  2572.     @Override
  2573.     public void updateApiTags(ApiTags body, String nome, Integer versione, ProfiloEnum profilo, String soggetto) {
  2574.         IContext context = this.getContext();
  2575.         try {
  2576.             context.getLogger().info("Invocazione in corso ...");

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

  2581.             if (body == null)
  2582.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un body");

  2584.             final ApiEnv env = new ApiEnv(profilo, soggetto, context);
  2585.             final AccordoServizioParteComune as = ApiApiHelper.getAccordoFull(nome, versione, env);
  2586.             
  2587.             if (as == null)
  2588.                 throw FaultCode.NOT_FOUND.toException("Nessuna Api registrata con nome " + nome + " e versione " + versione);
  2589.             
  2590.             final IDAccordo oldIdAccordo = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2591.             
  2592.             List<Object> objectToCreate = new ArrayList<>();
  2593.             
  2594.             if(body.getTags()==null || body.getTags().isEmpty()) {
  2595.                 as.setGruppi(null);
  2596.             }
  2597.             else {
  2598.                 as.setGruppi(new GruppiAccordo()); // annullo eventuali tags presenti.
  2599.                 
  2600.                 GruppiCore gruppiCore = new GruppiCore(env.stationCore);
  2601.                 
  2602.                 for (String tag : body.getTags()) {
  2603.                     GruppoAccordo gruppo = new GruppoAccordo();
  2604.                     gruppo.setNome(tag);
  2605.                     as.getGruppi().addGruppo(gruppo);
  2606.                     
  2607.                     if(!gruppiCore.existsGruppo(tag)) {
  2608.                         Gruppo nuovoGruppo = new Gruppo();
  2609.                         nuovoGruppo.setNome(tag);
  2610.                         nuovoGruppo.setSuperUser(as.getSuperUser());
  2611.                         objectToCreate.add(nuovoGruppo);
  2612.                     }
  2613.                 }
  2614.             }
  2615.             
  2616.             boolean validazioneDocumenti = ServerProperties.getInstance().isValidazioneDocumenti();

  2618.             BinaryParameter wsdlserv = new BinaryParameter();
  2619.             wsdlserv.setValue(as.getByteWsdlLogicoErogatore());

  2621.             BinaryParameter wsdlconc = new BinaryParameter();
  2622.             wsdlconc.setValue(as.getByteWsdlConcettuale());

  2624.             BinaryParameter wsdldef = new BinaryParameter();
  2625.             wsdldef.setValue(as.getByteWsdlDefinitorio());

  2627.             /*
  2628.              * boolean visibilitaAccordoCooperazione=false;
  2629.              * if("-".equals(this.accordoCooperazioneId)==false &&
  2630.              * "".equals(this.accordoCooperazioneId)==false &&
  2631.              * this.accordoCooperazioneId!=null){ AccordoCooperazione ac =
  2632.              * acCore.getAccordoCooperazione(Long.parseLong(this.accordoCooperazioneId));
  2633.              * visibilitaAccordoCooperazione=ac.getPrivato()!=null && ac.getPrivato(); }
  2634.              */

  2636.             StringBuilder bfTags = new StringBuilder();
  2637.             if(as.getGruppi()!=null && as.getGruppi().getGruppoList()!=null && !as.getGruppi().getGruppoList().isEmpty()) {
  2638.                 for (GruppoAccordo tag : as.getGruppi().getGruppoList()) {
  2639.                     if(bfTags.length()>0) {
  2640.                         bfTags.append(",");
  2641.                     }
  2642.                     bfTags.append(tag.getNome());
  2643.                 }
  2644.             }
  2645.             
  2646.             boolean gestioneCanaliEnabled = env.gestioneCanali;
  2647.             String canale = as.getCanale();
  2648.             String canaleStato = null;
  2649.             if(canale == null) {
  2650.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_DEFAULT;
  2651.             } else {
  2652.                 canaleStato = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_CANALE_STATO_RIDEFINITO;
  2653.             }
  2654.             
  2655.             if (!env.apcHelper.accordiCheckData(TipoOperazione.CHANGE, as.getNome(), as.getDescrizione(),
  2656.                     as.getProfiloCollaborazione().toString(), Helper.toBinaryParameter(as.getByteWsdlDefinitorio()),
  2657.                     Helper.toBinaryParameter(as.getByteWsdlConcettuale()),
  2658.                     Helper.toBinaryParameter(as.getByteWsdlLogicoErogatore()),
  2659.                     Helper.toBinaryParameter(as.getByteWsdlLogicoFruitore()),
  2660.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getFiltroDuplicati()),
  2661.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConfermaRicezione()),
  2662.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdCollaborazione()),
  2663.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getIdRiferimentoRichiesta()),
  2664.                     AccordiServizioParteComuneHelper.convertAbilitatoDisabilitatoDB2View(as.getConsegnaInOrdine()),
  2665.                     as.getScadenza() == null ? "" : as.getScadenza(), as.getId().toString(), as.getSoggettoReferente().getNome(),
  2666.                     as.getVersione().toString(), null, // AccordoCooperazioneID
  2667.                     false, // privato false, null,
  2668.                     false, // visibilitaAccordoCooperazione
  2669.                     oldIdAccordo, // idAccordoOld
  2670.                     null, // wsblconc
  2671.                     null, // wsblserv
  2672.                     null, // wsblservrorr
  2673.                     validazioneDocumenti, env.tipo_protocollo, null, // backToStato
  2674.                     env.apcCore.toMessageServiceBinding(as.getServiceBinding()), null, // MessageType
  2675.                     Enums.interfaceTypeFromFormatoSpecifica.get(as.getFormatoSpecifica()), env.gestisciSoggettoReferente,
  2676.                     bfTags.toString(),
  2677.                     canaleStato, canale, gestioneCanaliEnabled)) {

  2679.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(StringEscapeUtils.unescapeHtml(env.pd.getMessage()));
  2680.             }

  2682.             // Il profilo di collaborazione di base è Sincrono.
  2683.             // Quindi Nella AccordiServizioPArteComuneChange così come nella Add possiamo
  2684.             // assumerlo costante.
  2685.             // Sono i Servizi e le Azioni ad avere un profilo di collaborazione

  2687.             as.setOldIDAccordoForUpdate(oldIdAccordo);
  2688.             List<Object> operazioniList = new ArrayList<>(Arrays.asList(as));

  2690.             // Questa roba non serve qui perchè la updateDescrizione non cambia il nome e
  2691.             // quindi nemmeno l'ID.
  2692.             IDAccordo idNEW = env.idAccordoFactory.getIDAccordoFromAccordo(as);
  2693.             if (idNEW.equals(oldIdAccordo) == false) {
  2694.                 AccordiServizioParteComuneUtilities.findOggettiDaAggiornare(oldIdAccordo, as, env.apcCore, operazioniList);
  2695.             }

  2697.             
  2698.             // effettuo le operazioni
  2699.             if(objectToCreate.size()>0) {
  2700.                 env.apcCore.performCreateOperation(env.userLogin, false, objectToCreate.toArray(new Object[objectToCreate.size()]));
  2701.             }
  2702.             
  2703.             env.apcCore.performUpdateOperation(env.userLogin, false, operazioniList.toArray());

  2705.             context.getLogger().info("Invocazione completata con successo");
  2706.         } catch (javax.ws.rs.WebApplicationException e) {
  2707.             context.getLogger().error_except404("Invocazione terminata con errore '4xx': %s", e, e.getMessage());
  2708.             throw e;
  2709.         } catch (Throwable e) {
  2710.             context.getLogger().error("Invocazione terminata con errore: %s", e, e.getMessage());
  2711.             throw FaultCode.ERRORE_INTERNO.toException(e);
  2712.         }
  2713.     }


  2716. }
Created with JaCoCo 0.8.8.202204050719