ApiApiHelper.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 static org.openspcoop2.utils.service.beans.utils.BaseHelper.evalnull;
  23. import static org.openspcoop2.utils.service.beans.utils.ProfiloUtils.toProfilo;

  25. import java.util.ArrayList;
  26. import java.util.List;
  27. import java.util.Objects;

  29. import org.apache.commons.lang3.StringUtils;
  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.commons.Liste;
  32. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  33. import org.openspcoop2.core.config.rs.server.api.impl.Enums;
  34. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  35. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  36. import org.openspcoop2.core.config.rs.server.model.Api;
  37. import org.openspcoop2.core.config.rs.server.model.ApiAllegato;
  38. import org.openspcoop2.core.config.rs.server.model.ApiAllegatoGenerico;
  39. import org.openspcoop2.core.config.rs.server.model.ApiAllegatoItem;
  40. import org.openspcoop2.core.config.rs.server.model.ApiAllegatoItemGenerico;
  41. import org.openspcoop2.core.config.rs.server.model.ApiAllegatoItemSpecificaSemiformale;
  42. import org.openspcoop2.core.config.rs.server.model.ApiAllegatoSpecificaSemiformale;
  43. import org.openspcoop2.core.config.rs.server.model.ApiAzione;
  44. import org.openspcoop2.core.config.rs.server.model.ApiCanale;
  45. import org.openspcoop2.core.config.rs.server.model.ApiInterfacciaRest;
  46. import org.openspcoop2.core.config.rs.server.model.ApiInterfacciaSoap;
  47. import org.openspcoop2.core.config.rs.server.model.ApiItem;
  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.CanaleEnum;
  51. import org.openspcoop2.core.config.rs.server.model.FormatoRestEnum;
  52. import org.openspcoop2.core.config.rs.server.model.FormatoSoapEnum;
  53. import org.openspcoop2.core.config.rs.server.model.HttpMethodEnum;
  54. import org.openspcoop2.core.config.rs.server.model.RuoloAllegatoAPI;
  55. import org.openspcoop2.core.config.rs.server.model.StatoApiEnum;
  56. import org.openspcoop2.core.config.rs.server.model.TipoApiEnum;
  57. import org.openspcoop2.core.config.rs.server.model.TipoSpecificaSemiformaleEnum;
  58. import org.openspcoop2.core.id.IDAccordo;
  59. import org.openspcoop2.core.id.IDPortTypeAzione;
  60. import org.openspcoop2.core.id.IDResource;
  61. import org.openspcoop2.core.id.IDSoggetto;
  62. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  63. import org.openspcoop2.core.registry.Documento;
  64. import org.openspcoop2.core.registry.IdSoggetto;
  65. import org.openspcoop2.core.registry.Message;
  66. import org.openspcoop2.core.registry.Operation;
  67. import org.openspcoop2.core.registry.PortType;
  68. import org.openspcoop2.core.registry.Resource;
  69. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  70. import org.openspcoop2.core.registry.beans.GruppoSintetico;
  71. import org.openspcoop2.core.registry.constants.BindingUse;
  72. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  73. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  74. import org.openspcoop2.core.registry.constants.HttpMethod;
  75. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  76. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  77. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  78. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  79. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  80. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  81. import org.openspcoop2.message.constants.ServiceBinding;
  82. import org.openspcoop2.protocol.basic.archive.APIUtils;
  83. import org.openspcoop2.protocol.information_missing.constants.StatoType;
  84. import org.openspcoop2.protocol.manifest.constants.InterfaceType;
  85. import org.openspcoop2.protocol.sdk.ProtocolException;
  86. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  87. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  88. import org.openspcoop2.protocol.sdk.properties.ConsoleConfiguration;
  89. import org.openspcoop2.protocol.sdk.properties.IConsoleDynamicConfiguration;
  90. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  91. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  92. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  93. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  94. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  95. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  96. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  97. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  98. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneUtilities;
  99. import org.openspcoop2.web.ctrlstat.servlet.apc.api.ApiCostanti;
  100. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;

  102. /**
  103.  * ApiApiHelper
  104.  * 
  105.  * @author $Author$
  106.  * @version $Rev$, $Date$
  107.  * 
  108.  */
  109. public class ApiApiHelper {



  113.     public static void validateProperties(ApiEnv env, ProtocolProperties protocolProperties, IDAccordo idAccordoFromAccordo,
  114.             ConsoleOperationType operationType)
  115.             throws DriverConfigurazioneException {
  116.         if(protocolProperties!=null) {
  117.             try{

  119.                 ConsoleConfiguration consoleConf = getConsoleConfiguration(env, idAccordoFromAccordo);

  121.                 env.apcHelper.validaProtocolProperties(consoleConf, ConsoleOperationType.ADD, protocolProperties);
  122.                 
  123.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  124.                 IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  125.                 IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);
  126.                 consoleDynamicConfiguration.updateDynamicConfigAccordoServizioParteComune(consoleConf, operationType, env.apcHelper, protocolProperties, 
  127.                         registryReader, configRegistryReader, idAccordoFromAccordo);
  128.                 
  129.                 consoleDynamicConfiguration.validateDynamicConfigAccordoServizioParteComune(consoleConf, operationType, env.apcHelper, protocolProperties, 
  130.                         registryReader, configRegistryReader, idAccordoFromAccordo);
  131.                 
  132.             }catch(ProtocolException e){
  133.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(e.getMessage());
  134.             }
  135.         }
  136.     }

  138.     public static ConsoleConfiguration getConsoleConfiguration(ApiEnv env, IDAccordo idAccordoFromAccordo)
  139.             throws ProtocolException, DriverConfigurazioneException {
  140.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  142.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  143.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  145.         ConsoleConfiguration consoleConf = consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteComune(ConsoleOperationType.ADD, env.apcHelper, 
  146.                 registryReader, configRegistryReader, idAccordoFromAccordo);
  147.         return consoleConf;
  148.     }

  150.     public static void validateProperties(ApiEnv env, ProtocolProperties protocolProperties, IDResource idResource, String method, String path,
  151.             ConsoleOperationType operationType)
  152.             throws DriverConfigurazioneException {
  153.         if(protocolProperties!=null) {
  154.             try{

  156.                 ConsoleConfiguration consoleConf = getConsoleConfiguration(env, idResource, method, path);

  158.                 env.apcHelper.validaProtocolProperties(consoleConf, ConsoleOperationType.ADD, protocolProperties);
  159.                 
  160.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  161.                 IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  162.                 IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);
  163.                 consoleDynamicConfiguration.updateDynamicConfigResource(consoleConf, operationType, env.apcHelper, protocolProperties, 
  164.                         registryReader, configRegistryReader, idResource, method, path);
  165.                 
  166.                 consoleDynamicConfiguration.validateDynamicConfigResource(consoleConf, operationType, env.apcHelper, protocolProperties, 
  167.                         registryReader, configRegistryReader, idResource, method, path);
  168.                 
  169.             }catch(ProtocolException e){
  170.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(e.getMessage());
  171.             }
  172.         }
  173.     }
  174.     
  175.     public static ConsoleConfiguration getConsoleConfiguration(ApiEnv env, IDResource idResource, String method, String path)
  176.             throws ProtocolException, DriverConfigurazioneException {
  177.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  179.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  180.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  182.         ConsoleConfiguration consoleConf = consoleDynamicConfiguration.getDynamicConfigResource(ConsoleOperationType.ADD, env.apcHelper, registryReader, configRegistryReader,
  183.                 idResource, method, path);
  184.         return consoleConf;
  185.     }

  187.     public static void validateProperties(ApiEnv env, ProtocolProperties protocolProperties, IDPortTypeAzione idAccordoAzione,
  188.             ConsoleOperationType operationType)
  189.             throws DriverConfigurazioneException {
  190.         if(protocolProperties!=null) {
  191.             try{

  193.                 ConsoleConfiguration consoleConf = getConsoleConfiguration(env, idAccordoAzione);

  195.                 env.apcHelper.validaProtocolProperties(consoleConf, ConsoleOperationType.ADD, protocolProperties);
  196.                 
  197.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  198.                 IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  199.                 IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);
  200.                 consoleDynamicConfiguration.updateDynamicConfigOperation(consoleConf, operationType, env.apcHelper, protocolProperties, 
  201.                         registryReader, configRegistryReader, idAccordoAzione);
  202.                 
  203.                 consoleDynamicConfiguration.validateDynamicConfigOperation(consoleConf, operationType, env.apcHelper, protocolProperties, 
  204.                         registryReader, configRegistryReader, idAccordoAzione);
  205.                 
  206.             }catch(ProtocolException e){
  207.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(e.getMessage());
  208.             }
  209.         }
  210.     }
  211.     
  212.     public static ConsoleConfiguration getConsoleConfiguration(ApiEnv env, IDPortTypeAzione idAccordoAzione)
  213.             throws ProtocolException, DriverConfigurazioneException {
  214.         
  215.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();

  217.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  218.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  220.         ConsoleConfiguration consoleConf = consoleDynamicConfiguration.getDynamicConfigOperation(ConsoleOperationType.ADD, env.apcHelper, registryReader, configRegistryReader,
  221.                 idAccordoAzione);
  222.         return consoleConf;
  223.     }

  225.     public static ProtocolProperties getProtocolProperties(ApiAzione body, ProfiloEnum profilo, AccordoServizioParteComune as, Operation op, ApiEnv env) throws Exception {
  226.         if(!profilo.equals(ProfiloEnum.MODI) && !profilo.equals(ProfiloEnum.MODIPA) && body.getModi() != null) {
  227.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione 'ModI' non conforme con il profilo '"+profilo+"' indicato");
  228.         }

  230.         switch(profilo) {
  231.         case APIGATEWAY:
  232.             return null;// trasparente 
  233.         case EDELIVERY:
  234.             return EDeliveryApiApiHelper.getProtocolProperties(body);
  235.         case FATTURAPA:
  236.             return FatturaPAApiApiHelper.getProtocolProperties(body);
  237.         case MODI:
  238.         case MODIPA:
  239.             return ModiApiApiHelper.getProtocolProperties(body, as, op, env);
  240.         case SPCOOP:
  241.             return SPCoopApiApiHelper.getProtocolProperties(body);
  242.         }
  243.         return null;
  244.     }


  247.     public static ProtocolProperties getProtocolProperties(ApiRisorsa body, ProfiloEnum profilo, Resource res, ApiEnv env) throws Exception {
  248.         if(!profilo.equals(ProfiloEnum.MODI) && !profilo.equals(ProfiloEnum.MODIPA) && body.getModi() != null) {
  249.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione 'ModI' non conforme con il profilo '"+profilo+"' indicato");
  250.         }

  252.         switch(profilo) {
  253.         case APIGATEWAY:
  254.             return null;// trasparente 
  255.         case EDELIVERY:
  256.             return EDeliveryApiApiHelper.getProtocolProperties(body);
  257.         case FATTURAPA:
  258.             return FatturaPAApiApiHelper.getProtocolProperties(body);
  259.         case MODI:
  260.         case MODIPA:
  261.             return ModiApiApiHelper.getProtocolProperties(body, res, env);
  262.         case SPCOOP:
  263.             return SPCoopApiApiHelper.getProtocolProperties(body);
  264.         }
  265.         return null;
  266.     }


  269.     public static ProtocolProperties getProtocolProperties(Api body, ProfiloEnum profilo) throws Exception {


  272.         if(!profilo.equals(ProfiloEnum.MODI) && !profilo.equals(ProfiloEnum.MODIPA) && body.getModi() != null) {
  273.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione 'ModI' non conforme con il profilo '"+profilo+"' indicato");
  274.         }

  276.         switch(profilo) {
  277.         case APIGATEWAY:
  278.             return null;// trasparente 
  279.         case EDELIVERY:
  280.             return EDeliveryApiApiHelper.getProtocolProperties(body);
  281.         case FATTURAPA:
  282.             return FatturaPAApiApiHelper.getProtocolProperties(body);
  283.         case MODI:
  284.         case MODIPA:
  285.             return ModiApiApiHelper.getProtocolProperties(body);
  286.         case SPCOOP:
  287.             return SPCoopApiApiHelper.getProtocolProperties(body);
  288.         }
  289.         return null;
  290.     }

  292.     public static final AccordoServizioParteComune accordoApiToRegistro(Api body, ApiEnv env) throws Exception {
  293.         AccordoServizioParteComune as = new AccordoServizioParteComune(); 

  295.         as.setNome(body.getNome());
  296.         as.setDescrizione(body.getDescrizione());
  297.         as.setProfiloCollaborazione(ProfiloCollaborazione.SINCRONO);

  299.         // Quando sono in SPCoopSoap Specifico di tutti i vari wsdl\wsbl solo il wsdlserv, ovvero  AccordiServizioParteComuneCostanti.PARAMETRO_APC_WSDL_EROGATORE
  300.         // Quando invece sono in modalità ApiGateway e passo una OpenApi, imposto il wsdlconcettuale
  301.         String interfaccia = body.getInterfaccia() != null ? new String(body.getInterfaccia()) : null;

  303.         // defaults
  304.         // Questo codice e il controllo sotto non dovrebbero mai intervenire essendo tipo required
  305.         if (env.profilo != ProfiloEnum.APIGATEWAY) {

  307.             if (body.getTipoInterfaccia() == null) {
  308.                 ApiInterfacciaSoap iSoap = new ApiInterfacciaSoap();
  309.                 iSoap.setProtocollo(TipoApiEnum.SOAP);
  310.                 iSoap.setFormato(FormatoSoapEnum._1);
  311.                 body.setTipoInterfaccia(iSoap); 
  312.             }
  313.         }

  315.         if ( env.profilo == ProfiloEnum.APIGATEWAY ) {

  317.             if ( body.getTipoInterfaccia() == null ) {
  318.                 ApiInterfacciaRest iRest = new ApiInterfacciaRest();
  319.                 iRest.setProtocollo(TipoApiEnum.REST);
  320.                 iRest.setFormato(FormatoRestEnum.OPENAPI3_0);
  321.                 body.setTipoInterfaccia(iRest); 
  322.             }

  324.         }

  326.         if ( body.getTipoInterfaccia() == null )    // Questo non può mai accadere, lo tengo perchè in futuro il codice sopra potrà cambiare.
  327.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Specificare un tipo di interfaccia per la Api");

  329.         switch (body.getTipoInterfaccia().getProtocollo()) {
  330.         case REST:

  332.             if(body.getTipoInterfaccia() instanceof ApiInterfacciaSoap) {
  333.                 ApiInterfacciaSoap soap = (ApiInterfacciaSoap) body.getTipoInterfaccia();
  334.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il formato dell'interfaccia ("+soap.getFormato()+") non è compatibile con il protocollo REST indicato");
  335.             }
  336.             else if(body.getTipoInterfaccia() instanceof ApiInterfacciaRest) {
  337.                 ApiInterfacciaRest iRest = (ApiInterfacciaRest) body.getTipoInterfaccia();

  339.                 as.setByteWsdlConcettuale(interfaccia != null && !interfaccia.trim().replaceAll("\n", "").equals("") ? interfaccia.trim().getBytes() : null);
  340.                 FormatoRestEnum formatoRest = iRest.getFormato();
  341.                 as.setFormatoSpecifica( BaseHelper.evalorElse( () -> 
  342.                 Enums.formatoSpecificaFromRest.get(formatoRest),
  343.                 FormatoSpecifica.OPEN_API_3
  344.                         )); 
  345.             }
  346.             else {
  347.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il formato dell'interfaccia ("+body.getTipoInterfaccia().getClass().getName()+") risulta sconosciuto e non compatibile con il protocollo REST indicato");
  348.             }

  350.             break;
  351.         case SOAP: 

  353.             if(body.getTipoInterfaccia() instanceof ApiInterfacciaRest) {
  354.                 ApiInterfacciaRest rest = (ApiInterfacciaRest) body.getTipoInterfaccia();
  355.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il formato dell'interfaccia ("+rest.getFormato()+") non è compatibile con il protocollo SOAP indicato");
  356.             }
  357.             else if(body.getTipoInterfaccia() instanceof ApiInterfacciaSoap) {
  358.                 ApiInterfacciaSoap iSoap = (ApiInterfacciaSoap) body.getTipoInterfaccia();

  360.                 FormatoSoapEnum formatoSoap = iSoap.getFormato();
  361.                 as.setFormatoSpecifica( BaseHelper.evalorElse( 
  362.                         () -> Enums.formatoSpecificaFromSoap.get(formatoSoap), 
  363.                         FormatoSpecifica.WSDL_11 
  364.                         ));
  365.                 as.setByteWsdlLogicoErogatore(interfaccia != null && !interfaccia.trim().replaceAll("\n", "").equals("") ? interfaccia.trim().getBytes() : null);   // Da commenti e audit, WSDL solo logico ed erogatore
  366.             }
  367.             else {
  368.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il formato dell'interfaccia ("+body.getTipoInterfaccia().getClass().getName()+") risulta sconosciuto e non compatibile con il protocollo SOAP indicato");
  369.             }

  371.             break;
  372.         }

  374.         as.setServiceBinding(env.apcCore.fromMessageServiceBinding(Enums.serviceBindingFromTipo.get(body.getTipoInterfaccia().getProtocollo())));

  376.         boolean facilityUnicoWSDL_interfacciaStandard = false;
  377.         if(as.getByteWsdlLogicoErogatore()!=null && as.getByteWsdlLogicoFruitore()==null && as.getByteWsdlConcettuale()==null){
  378.             as.setByteWsdlConcettuale(as.getByteWsdlLogicoErogatore());
  379.             facilityUnicoWSDL_interfacciaStandard = true;
  380.         }

  382.         boolean filtroDuplicatiSupportato = env.stationCore.isFunzionalitaProtocolloSupportataDalProtocollo(
  383.                 env.tipo_protocollo, 
  384.                 env.apcCore.toMessageServiceBinding(as.getServiceBinding())
  385.                 , FunzionalitaProtocollo.FILTRO_DUPLICATI
  386.                 );

  388.         as.setFiltroDuplicati(Helper.boolToStatoFunzionalita(filtroDuplicatiSupportato));
  389.         as.setConfermaRicezione(StatoFunzionalita.DISABILITATO);
  390.         as.setIdCollaborazione(StatoFunzionalita.DISABILITATO);
  391.         as.setConsegnaInOrdine(StatoFunzionalita.DISABILITATO);
  392.         as.setIdRiferimentoRichiesta(StatoFunzionalita.DISABILITATO);
  393.         as.setUtilizzoSenzaAzione(true);    // Default a true.
  394.         as.setPrivato(false);   // Da Audit è false.
  395.         as.setStatoPackage(StatoType.FINALE.getValue());    // Come da Audit

  397.         if (body.getVersione() != null)
  398.             as.setVersione(body.getVersione());

  400.         as.setSuperUser(env.userLogin);

  402.         // Questo resta a null dal debug anche quando specifico un wsdl
  403.         // as.setMessageType(apcCore.fromMessageMessageType(this.messageType));

  405.         // Setto il soggetto referente, true in caso di "spcoop" "sdi", "as4"
  406.         // Se non lo gestisco (caso "trasparente") allora è il sistema a legare l'applicativo con un soggetto di default.
  407.         IdSoggetto idSoggReferente = new IdSoggetto();
  408.         if (env.gestisciSoggettoReferente) {            
  409.             idSoggReferente.setNome(Helper.getSoggettoOrDefault(body.getReferente(), env.profilo));
  410.             idSoggReferente.setTipo(env.tipo_soggetto);
  411.         }
  412.         else {
  413.             IDSoggetto idSogg = env.apcCore.getSoggettoOperativoDefault(env.userLogin, env.tipo_protocollo);
  414.             idSoggReferente.setNome(idSogg.getNome());
  415.             idSoggReferente.setTipo(idSogg.getTipo());
  416.         }

  418.         if (!env.soggettiCore.existsSoggetto(idSoggReferente.toIDSoggetto())) {
  419.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il soggetto referente " + idSoggReferente.toIDSoggetto().toString() + " non è presente nel registro");
  420.         }

  422.         idSoggReferente.setId(env.soggettiCore.getIdSoggetto(idSoggReferente.getNome(),idSoggReferente.getTipo()));

  424.         as.setSoggettoReferente(idSoggReferente);

  426.         // Canale
  427.         if(env.gestioneCanali && body.getCanale()!=null) {
  428.             if(!env.canali.contains(body.getCanale())) {
  429.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il canale fornito '" + body.getCanale() + "' non è presente nel registro");
  430.             }
  431.             as.setCanale(body.getCanale());
  432.         }

  434.         // Automapping
  435.         ServerProperties properties = ServerProperties.getInstance();
  436.         InterfaceType interfaceType = Enums.interfaceTypeFromFormatoSpecifica.get(as.getFormatoSpecifica());

  438.         AccordiServizioParteComuneUtilities.mapppingAutomaticoInterfaccia(
  439.                 as,
  440.                 env.apcCore, 
  441.                 properties.isEnabledAutoMapping(),
  442.                 properties.isValidazioneDocumenti(),
  443.                 properties.isEnabledAutoMappingEstraiXsdSchemiFromWsdlTypes(),
  444.                 facilityUnicoWSDL_interfacciaStandard, 
  445.                 env.tipo_protocollo, interfaceType);


  448.         return as;
  449.     }


  452.     public static final Documento apiAllegatoToDocumento(ApiAllegato body, AccordoServizioParteComune as, ApiEnv env) {

  454.         Documento documento = new Documento();
  455.         documento.setIdProprietarioDocumento(as.getId());

  457.         RuoloAllegatoAPI ruoloAllegato = body.getAllegato().getRuolo();

  459.         documento.setRuolo(Enums.ruoliDocumentoFromApi.get(ruoloAllegato).toString());

  461.         switch (ruoloAllegato) {
  462.         case ALLEGATO:

  464.             if(! (body.getAllegato() instanceof ApiAllegatoGenerico)) {
  465.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'allegato fornito possiede una struttura dati '"+body.getAllegato().getClass().getName()+"' non compatibile con il ruolo '"+ruoloAllegato+"'");
  466.             }
  467.             ApiAllegatoGenerico allegatoGenerico = (ApiAllegatoGenerico) body.getAllegato();
  468.             documento.setFile(allegatoGenerico.getNome());
  469.             documento.setByteContenuto(allegatoGenerico.getDocumento());
  470.             documento.setTipo( evalnull( () -> allegatoGenerico.getNome().substring( allegatoGenerico.getNome().lastIndexOf('.')+1, allegatoGenerico.getNome().length())) );
  471.             break;

  473.         case SPECIFICASEMIFORMALE:

  475.             if(! (body.getAllegato() instanceof ApiAllegatoSpecificaSemiformale)) {
  476.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("L'allegato fornito possiede una struttura dati '"+body.getAllegato().getClass().getName()+"' non compatibile con il ruolo '"+ruoloAllegato+"'");
  477.             }
  478.             ApiAllegatoSpecificaSemiformale allegatoSS = (ApiAllegatoSpecificaSemiformale) body.getAllegato();
  479.             documento.setFile(allegatoSS.getNome());
  480.             documento.setByteContenuto(allegatoSS.getDocumento());
  481.             if(ApiCheckNotNull.isNotNullTipoSpecifica(allegatoSS, documento)) {
  482.                 TipoSpecificaSemiformaleEnum tipoAllegato = (TipoSpecificaSemiformaleEnum) allegatoSS.getTipoSpecifica();
  483.                 documento.setTipo( evalnull( () -> Enums.tipoDocumentoSemiFormaleFromSpecifica.get(tipoAllegato) ).toString() );
  484.             }
  485.             break;
  486.         }

  488.         return documento;
  489.     }


  492.     public static final ApiAllegato documentoToApiAllegato(Documento d) {
  493.         ApiAllegato ret = new ApiAllegato();

  495.         RuoloAllegatoAPI ruoloAllegato = Enums.ruoliApiFromDocumento.get(Enum.valueOf(RuoliDocumento.class, d.getRuolo()));

  497.         switch (ruoloAllegato) {
  498.         case ALLEGATO:

  500.             ApiAllegatoGenerico allegatoGenerico = new ApiAllegatoGenerico();
  501.             allegatoGenerico.setRuolo(ruoloAllegato);
  502.             allegatoGenerico.setDocumento(d.getByteContenuto());
  503.             allegatoGenerico.setNome(d.getFile());
  504.             ret.setAllegato(allegatoGenerico);
  505.             break;

  507.         case SPECIFICASEMIFORMALE:

  509.             ApiAllegatoSpecificaSemiformale allegatoSS = new ApiAllegatoSpecificaSemiformale();
  510.             allegatoSS.setRuolo(ruoloAllegato);
  511.             allegatoSS.setDocumento(d.getByteContenuto());
  512.             allegatoSS.setNome(d.getFile());
  513.             TipiDocumentoSemiformale tipo = TipiDocumentoSemiformale.toEnumConstant(d.getTipo());
  514.             allegatoSS.setTipoSpecifica((Helper.apiEnumToGovway(tipo, TipoSpecificaSemiformaleEnum.class)));
  515.             ret.setAllegato(allegatoSS);
  516.             break;
  517.         }

  519.         return ret;
  520.     }

  522.     public static final ApiAllegatoItem documentoToApiAllegatoItem(Documento d) {
  523.         ApiAllegatoItem ret = new ApiAllegatoItem();

  525.         RuoloAllegatoAPI ruoloAllegato = Enums.ruoliApiFromDocumento.get(Enum.valueOf(RuoliDocumento.class, d.getRuolo()));

  527.         switch (ruoloAllegato) {
  528.         case ALLEGATO:

  530.             ApiAllegatoItemGenerico allegatoGenerico = new ApiAllegatoItemGenerico();
  531.             allegatoGenerico.setRuolo(ruoloAllegato);
  532.             allegatoGenerico.setNome(d.getFile());
  533.             ret.setAllegato(allegatoGenerico);
  534.             break;

  536.         case SPECIFICASEMIFORMALE:

  538.             ApiAllegatoItemSpecificaSemiformale allegatoSS = new ApiAllegatoItemSpecificaSemiformale();
  539.             allegatoSS.setRuolo(ruoloAllegato);
  540.             allegatoSS.setNome(d.getFile());
  541.             TipiDocumentoSemiformale tipo = TipiDocumentoSemiformale.toEnumConstant(d.getTipo());
  542.             allegatoSS.setTipoSpecifica((Helper.apiEnumToGovway(tipo, TipoSpecificaSemiformaleEnum.class)));
  543.             ret.setAllegato(allegatoSS);
  544.             break;
  545.         }

  547.         return ret;
  548.     }

  550.     public static final void updatePortType(ApiServizio body, PortType pt, ApiEnv env) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {

  552.         pt.setNome(body.getNome());
  553.         pt.setDescrizione(body.getDescrizione());

  555.         boolean filtroDuplicatiSupportato = env.stationCore.isFunzionalitaProtocolloSupportataDalProtocollo(
  556.                 env.tipo_protocollo, 
  557.                 ServiceBinding.SOAP
  558.                 , FunzionalitaProtocollo.FILTRO_DUPLICATI
  559.                 );

  561.         pt.setFiltroDuplicati(Helper.boolToStatoFunzionalita(filtroDuplicatiSupportato));   
  562.         pt.setIdCollaborazione(Helper.boolToStatoFunzionalita(body.isIdCollaborazione()));
  563.         pt.setIdRiferimentoRichiesta(Helper.boolToStatoFunzionalita(body.isRiferimentoIdRichiesta()));
  564.         pt.setProfiloPT(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  565.         pt.setProfiloCollaborazione(Enums.profiloCollaborazioneFromApiEnum.get(body.getProfiloCollaborazione()));           
  566.     }


  569.     public static final void updateOperation(ApiAzione azione, PortType parent, Operation to_update) {

  571.         to_update.setNome(azione.getNome());    

  573.         if (azione.isProfiloRidefinito()) {
  574.             to_update.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  575.             to_update.setIdCollaborazione(Helper.boolToStatoFunzionalita(azione.isIdCollaborazione()));
  576.             to_update.setIdRiferimentoRichiesta(Helper.boolToStatoFunzionalita(azione.isRiferimentoIdRichiesta()));
  577.             to_update.setProfiloCollaborazione(Enums.profiloCollaborazioneFromApiEnum.get(azione.getProfiloCollaborazione()));
  578.         }
  579.         else {
  580.             to_update.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT);
  581.             to_update.setFiltroDuplicati(parent.getFiltroDuplicati());
  582.             to_update.setConfermaRicezione(parent.getConfermaRicezione());
  583.             to_update.setConsegnaInOrdine(parent.getConsegnaInOrdine());
  584.             to_update.setIdCollaborazione(parent.getIdCollaborazione());
  585.             to_update.setIdRiferimentoRichiesta(parent.getIdRiferimentoRichiesta());
  586.             to_update.setProfiloCollaborazione(parent.getProfiloCollaborazione());
  587.             to_update.setScadenza(parent.getScadenza());
  588.         }       
  589.     }


  592.     public static final Operation apiAzioneToOperazione(ApiAzione azione, PortType parent) {
  593.         final Operation ret = new Operation();
  594.         updateOperation(azione, parent, ret);

  596.         final String useOp = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_PORT_TYPE_OPERATION_USE;
  597.         final String namespaceWsdlOp = "";

  599.         final BindingUse use = BindingUse.toEnumConstant(useOp);
  600.         ret.setMessageInput(new Message());
  601.         ret.getMessageInput().setSoapNamespace(namespaceWsdlOp);
  602.         ret.getMessageInput().setUse(use);

  604.         // Se il profilo non è oneWay dobbiamo specificare anche in mesaggio di i uscita, la comunicazione diventa a due vie.
  605.         if (ret.getProfiloCollaborazione() != ProfiloCollaborazione.ONEWAY) {
  606.             ret.setMessageOutput(new Message());
  607.             ret.getMessageOutput().setSoapNamespace(namespaceWsdlOp);
  608.             ret.getMessageOutput().setUse(use);
  609.         }

  611.         return ret;
  612.     }

  614.     public static final ApiAzione operazioneToApiAzione(Operation op) {
  615.         ApiAzione ret = new ApiAzione();

  617.         ret.setNome(op.getNome());
  618.         ret.setIdCollaborazione(op.getIdCollaborazione() == StatoFunzionalita.ABILITATO ? true : false);
  619.         ret.setRiferimentoIdRichiesta(op.getIdRiferimentoRichiesta() == StatoFunzionalita.ABILITATO ? true : false);
  620.         ret.setProfiloCollaborazione(Enums.profiloCollaborazioneApiFromRegistro.get(op.getProfiloCollaborazione()));
  621.         ret.setProfiloRidefinito(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(op.getProfAzione()) ? true : false);

  623.         return ret;
  624.     }


  627.     public static final PortType apiServizioToRegistro(ApiServizio body, AccordoServizioParteComune parent, ApiEnv env) throws DriverRegistroServiziNotFound, DriverRegistroServiziException {

  629.         PortType ret = new PortType();

  631.         updatePortType(body, ret, env);

  633.         ret.setScadenza("");
  634.         ret.setConfermaRicezione(parent.getConfermaRicezione());
  635.         ret.setConsegnaInOrdine(parent.getConsegnaInOrdine());

  637.         return ret;
  638.     }




  643.     public static final ApiServizio servizioRegistroToApi(PortType pt) {
  644.         ApiServizio ret = new ApiServizio();
  645.         ret.setNome(pt.getNome());
  646.         ret.setDescrizione(pt.getDescrizione());
  647.         ret.setIdCollaborazione(Helper.statoFunzionalitaToBool(pt.getIdCollaborazione()));
  648.         ret.setRiferimentoIdRichiesta(Helper.statoFunzionalitaToBool(pt.getIdRiferimentoRichiesta()));
  649.         ret.setProfiloCollaborazione(Enums.profiloCollaborazioneApiFromRegistro.get(pt.getProfiloCollaborazione()));

  651.         return ret;
  652.     }


  655.     public static final void updateRisorsa(ApiRisorsa body, Resource res) {

  657.         res.setNome(body.getNome());
  658.         res.setDescrizione(body.getDescrizione());

  660.         // 1. se il path non inizia per '/' aggiungo all'inizio della stringa
  661.         String pathNormalizzato = body.getPath();

  663.         if(pathNormalizzato !=null && !"".equals(pathNormalizzato)) {
  664.             pathNormalizzato = pathNormalizzato.trim();
  665.             if(!pathNormalizzato.startsWith("/"))
  666.                 pathNormalizzato = "/" + pathNormalizzato;
  667.         }

  669.         res.setPath(pathNormalizzato);

  671.         res.setMethod(Helper.apiEnumToGovway(body.getHttpMethod(), HttpMethod.class));

  673.         if (res.getMethod() != null)
  674.             res.setMethodRawEnumValue(res.getMethod().toString());

  676.         if (StringUtils.isEmpty(res.getNome()) && res.getMethod() != null)
  677.             res.setNome(APIUtils.normalizeResourceName(res.getMethod(), pathNormalizzato));

  679.         res.setIdCollaborazione( Helper.boolToStatoFunzionalita(body.isIdCollaborazione()));
  680.         res.setIdRiferimentoRichiesta( Helper.boolToStatoFunzionalita(body.isRiferimentoIdRichiesta()));        
  681.         res.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  682.     }

  684.     // Todo prendiFiltroDuplicati e roba dal parent.
  685.     public static final Resource apiRisorsaToRegistro(ApiRisorsa body, AccordoServizioParteComune parent) {
  686.         Resource ret = new Resource();

  688.         ret.setMessageType(null);
  689.         ret.setRequestMessageType(null);
  690.         ret.setResponseMessageType(null);
  691.         ret.setFiltroDuplicati(parent.getFiltroDuplicati());
  692.         ret.setConfermaRicezione(parent.getConfermaRicezione());
  693.         ret.setIdCollaborazione(parent.getIdCollaborazione());
  694.         ret.setIdRiferimentoRichiesta(parent.getIdRiferimentoRichiesta());
  695.         ret.setConsegnaInOrdine(parent.getConsegnaInOrdine());
  696.         ret.setScadenza(parent.getScadenza());      

  698.         updateRisorsa(body,ret);

  700.         return ret;
  701.     }


  704.     public static final ApiRisorsa risorsaRegistroToApi(Resource r) {
  705.         ApiRisorsa ret = new ApiRisorsa();

  707.         ret.setNome(r.getNome());
  708.         ret.setDescrizione(r.getDescrizione());

  710.         ret.setHttpMethod( r.getMethodRawEnumValue() == null || HttpMethodEnum.valueOf(r.getMethodRawEnumValue()) == null 
  711.                 ? HttpMethodEnum.QUALSIASI 
  712.                         : HttpMethodEnum.valueOf(r.getMethodRawEnumValue())
  713.                 );

  715.         ret.setIdCollaborazione(r.getIdCollaborazione() == StatoFunzionalita.ABILITATO ? true : false);
  716.         ret.setRiferimentoIdRichiesta(r.getIdRiferimentoRichiesta() == StatoFunzionalita.ABILITATO ? true : false);
  717.         ret.setPath(r.getPath());

  719.         return ret;
  720.     }

  722.     public static void populateApiRisorsaWithProtocolInfo(AccordoServizioParteComune as, Resource res, ApiEnv env, ProfiloEnum profilo, ApiRisorsa ret) throws Exception {
  723.         
  724.         if(profilo != null) {
  725.             switch(profilo) {
  726.             case APIGATEWAY:
  727.                 return ;// trasparente 
  728.             case EDELIVERY:
  729.                 EDeliveryApiApiHelper.populateApiRisorsaWithProtocolInfo(as, res, env, ret);
  730.                 break;
  731.             case FATTURAPA:
  732.                 FatturaPAApiApiHelper.populateApiRisorsaWithProtocolInfo(as, res, env, ret);
  733.                 break;
  734.             case MODI:
  735.             case MODIPA:
  736.                 ModiApiApiHelper.populateApiRisorsaWithProtocolInfo(as, res,  env, ret);
  737.                 break;
  738.             case SPCOOP:
  739.                 SPCoopApiApiHelper.populateApiRisorsaWithProtocolInfo(as, res, env, ret);
  740.             }
  741.         }       
  742.     }

  744.     public static void populateApiAzioneWithProtocolInfo(AccordoServizioParteComune as, Operation az, ApiEnv env, ProfiloEnum profilo, ApiAzione ret) throws Exception {
  745.         
  746.         if(profilo != null) {
  747.             switch(profilo) {
  748.             case APIGATEWAY:
  749.                 return ;// trasparente 
  750.             case EDELIVERY:
  751.                 EDeliveryApiApiHelper.populateApiAzioneWithProtocolInfo(as, az, env, ret);
  752.                 break;
  753.             case FATTURAPA:
  754.                 FatturaPAApiApiHelper.populateApiAzioneWithProtocolInfo(as, az, env, ret);
  755.                 break;
  756.             case MODI:
  757.             case MODIPA:
  758.                 ModiApiApiHelper.populateApiAzioneWithProtocolInfo(as, az,  env, ret);
  759.                 break;
  760.             case SPCOOP:
  761.                 SPCoopApiApiHelper.populateApiAzioneWithProtocolInfo(as, az, env, ret);
  762.             }
  763.         }       
  764.     }

  766.     public static final ApiItem apiToItem(Api api, AccordoServizioParteComuneSintetico as, ApiEnv env) {
  767.         ApiItem ret = new ApiItem();

  769.         ProfiloEnum profilo = toProfilo(as.getSoggettoReferente().getTipo());
  770.         ret.setDescrizione(api.getDescrizione());
  771.         ret.setTipoInterfaccia(api.getTipoInterfaccia());
  772.         ret.setNome(api.getNome());
  773.         ret.setProfilo(Objects.requireNonNullElse(profilo, ProfiloEnum.APIGATEWAY));
  774.         ret.setSoggetto(api.getReferente());
  775.         ret.setVersione(api.getVersione());
  776.         ret.setReferente(api.getReferente());


  779.         StatoApiEnum stato = null;
  780.         String descrizioneStato = "";
  781.         ConsoleSearch searchForCount = new ConsoleSearch(true);
  782.         switch (ret.getTipoInterfaccia().getProtocollo()) {
  783.         case REST:
  784.             // caso REST: l'API e' abilitata se ha almeno una risorsa
  785.             try {
  786.                 env.apcCore.accordiResourceList(as.getId().intValue(), searchForCount);
  787.             } catch (Exception e) { throw new RuntimeException(e); }

  789.             int numRisorse = searchForCount.getNumEntries(Liste.ACCORDI_API_RESOURCES);

  791.             if(numRisorse > 0) {
  792.                 stato = StatoApiEnum.OK;
  793.             }
  794.             else {
  795.                 stato = StatoApiEnum.ERROR;
  796.                 descrizioneStato = ApiCostanti.APC_API_ICONA_STATO_RISORSE_TUTTE_DISABILITATE_TOOLTIP;
  797.             }
  798.             break;
  799.         case SOAP:
  800.         default:

  802.             List<PortType> accordiPorttypeList = null;
  803.             try {
  804.                 accordiPorttypeList = env.apcCore.accordiPorttypeList(as.getId().intValue(), searchForCount);
  805.             } catch (Exception e) { throw new RuntimeException(e); }

  807.             int numeroTotaleServizi = accordiPorttypeList.size();
  808.             int numeroServiziAbilitati = 0;

  810.             for (PortType portType : accordiPorttypeList) {
  811.                 if(portType.sizeAzioneList()>0) {
  812.                     numeroServiziAbilitati ++;
  813.                 }   
  814.             }

  816.             if(numeroTotaleServizi == 0) {
  817.                 stato = StatoApiEnum.ERROR;
  818.                 descrizioneStato = ApiCostanti.APC_API_ICONA_STATO_SERVIZI_TUTTI_DISABILITATI_TOOLTIP;
  819.             }
  820.             else if(numeroServiziAbilitati==0) {
  821.                 stato = StatoApiEnum.ERROR;
  822.                 if(numeroTotaleServizi==1) {
  823.                     descrizioneStato = ApiCostanti.APC_API_ICONA_STATO_SERVIZIO_PARZIALMENTE_CONFIGURATO_DISABILITATI_TOOLTIP;
  824.                 }
  825.                 else {
  826.                     descrizioneStato = ApiCostanti.APC_API_ICONA_STATO_SERVIZI_TUTTI_SENZA_AZIONE_TOOLTIP;
  827.                 }
  828.             } else if(numeroServiziAbilitati == numeroTotaleServizi) {
  829.                 stato = StatoApiEnum.OK;
  830.             } 
  831.             else {
  832.                 stato = StatoApiEnum.WARN;
  833.                 descrizioneStato = ApiCostanti.APC_API_ICONA_STATO_SERVIZI_PARZIALMENTE_ABILITATI_TOOLTIP;
  834.             }
  835.             break;
  836.         }

  838.         ret.setStatoDescrizione(descrizioneStato);
  839.         ret.setStato(stato);

  841.         if(as.getGruppo()!=null &&  !as.getGruppo().isEmpty()) {
  842.             ret.setTags(new ArrayList<>());
  843.             for (GruppoSintetico tag : as.getGruppo()) {
  844.                 ret.addTagsItem(tag.getNome());
  845.             }
  846.         }

  848.         if(env.gestioneCanali) {
  849.             ApiCanale canale = new ApiCanale();
  850.             if(as.getCanale()!=null && !"".equals(as.getCanale())) {
  851.                 canale.setNome(as.getCanale());
  852.                 canale.setConfigurazione(CanaleEnum.API);
  853.             }
  854.             else {
  855.                 canale.setNome(env.canaleDefault);
  856.                 canale.setConfigurazione(CanaleEnum.DEFAULT);
  857.             }
  858.             ret.setCanale(canale);
  859.         }

  861.         return ret;

  863.     }

  865.     public static final Api accordoSpcRegistroToApi(AccordoServizioParteComuneSintetico as, SoggettiCore soggettiCore) {
  866.         Api ret = new Api();

  868.         ret.setNome(as.getNome());
  869.         ret.setDescrizione(as.getDescrizione());

  871.         switch (as.getServiceBinding()) {
  872.         case REST:
  873.             ApiInterfacciaRest iRest = new ApiInterfacciaRest();
  874.             iRest.setProtocollo(TipoApiEnum.REST);
  875.             iRest.setFormato(Enums.formatoRestFromSpecifica.get(as.getFormatoSpecifica()));
  876.             ret.setTipoInterfaccia(iRest);
  877.             ret.setInterfaccia(as.getByteWsdlConcettuale());
  878.             break;
  879.         case SOAP:
  880.             ApiInterfacciaSoap iSoap = new ApiInterfacciaSoap();
  881.             iSoap.setProtocollo(TipoApiEnum.SOAP);
  882.             iSoap.setFormato(Enums.formatoSoapFromSpecifica.get(as.getFormatoSpecifica()));
  883.             ret.setTipoInterfaccia(iSoap);
  884.             ret.setInterfaccia(as.getByteWsdlLogicoErogatore());
  885.             break;
  886.         }

  888.         ret.setVersione(as.getVersione());
  889.         ret.setReferente(as.getSoggettoReferente().getNome());

  891.         return ret; 
  892.     }


  895.     // Versione "deprecata" in favore di quella più generica nell'Helper
  896.     public static final AccordoServizioParteComune getAccordoFull(String nome, Integer versione, ApiEnv env) throws CoreException {
  897.         return Helper.getAccordoFull(nome, versione, env.idSoggetto.toIDSoggetto(), env.apcCore);
  898.     }
  899.     public static final AccordoServizioParteComuneSintetico getAccordoSintetico(String nome, Integer versione, ApiEnv env) throws CoreException {
  900.         return Helper.getAccordoSintetico(nome, versione, env.idSoggetto.toIDSoggetto(), env.apcCore);
  901.     }

  903. }
Created with JaCoCo 0.8.8.202204050719