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;

  24. import java.util.ArrayList;
  25. import java.util.List;

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

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



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

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

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

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

  140.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  141.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

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

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

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

  177.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  178.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

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

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

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

  215.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  216.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

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

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

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


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

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


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


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

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

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

  293.         as.setNome(body.getNome());
  294.         as.setDescrizione(body.getDescrizione());
  295.         as.setProfiloCollaborazione(ProfiloCollaborazione.SINCRONO);

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

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

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

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

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

  322.         }

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

  327.         switch (body.getTipoInterfaccia().getProtocollo()) {
  328.         case REST:

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

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

  348.             break;
  349.         case SOAP: 

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

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

  369.             break;
  370.         }

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

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

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

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

  395.         if (body.getVersione() != null)
  396.             as.setVersione(body.getVersione());

  398.         as.setSuperUser(env.userLogin);

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

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

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

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

  422.         as.setSoggettoReferente(idSoggReferente);

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

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

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


  446.         return as;
  447.     }


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

  452.         Documento documento = new Documento();
  453.         documento.setIdProprietarioDocumento(as.getId());

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

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

  459.         switch (ruoloAllegato) {
  460.         case ALLEGATO:

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

  471.         case SPECIFICASEMIFORMALE:

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

  486.         return documento;
  487.     }


  490.     public static final ApiAllegato documentoToApiAllegato(Documento d) {
  491.         ApiAllegato ret = new ApiAllegato();

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

  495.         switch (ruoloAllegato) {
  496.         case ALLEGATO:

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

  505.         case SPECIFICASEMIFORMALE:

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

  517.         return ret;
  518.     }

  520.     public static final ApiAllegatoItem documentoToApiAllegatoItem(Documento d) {
  521.         ApiAllegatoItem ret = new ApiAllegatoItem();

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

  525.         switch (ruoloAllegato) {
  526.         case ALLEGATO:

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

  534.         case SPECIFICASEMIFORMALE:

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

  545.         return ret;
  546.     }

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

  550.         pt.setNome(body.getNome());
  551.         pt.setDescrizione(body.getDescrizione());

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

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


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

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

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


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

  594.         final String useOp = AccordiServizioParteComuneCostanti.DEFAULT_VALUE_PARAMETRO_APC_PORT_TYPE_OPERATION_USE;
  595.         final String namespaceWsdlOp = "";

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

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

  609.         return ret;
  610.     }

  612.     public static final ApiAzione operazioneToApiAzione(Operation op) {
  613.         ApiAzione ret = new ApiAzione();

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

  621.         return ret;
  622.     }


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

  627.         PortType ret = new PortType();

  629.         updatePortType(body, ret, env);

  631.         ret.setScadenza("");
  632.         ret.setConfermaRicezione(parent.getConfermaRicezione());
  633.         ret.setConsegnaInOrdine(parent.getConsegnaInOrdine());

  635.         return ret;
  636.     }




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

  649.         return ret;
  650.     }


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

  655.         res.setNome(body.getNome());
  656.         res.setDescrizione(body.getDescrizione());

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

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

  667.         res.setPath(pathNormalizzato);

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

  671.         if (res.getMethod() != null)
  672.             res.setMethodRawEnumValue(res.getMethod().toString());

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

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

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

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

  696.         updateRisorsa(body,ret);

  698.         return ret;
  699.     }


  702.     public static final ApiRisorsa risorsaRegistroToApi(Resource r) {
  703.         ApiRisorsa ret = new ApiRisorsa();

  705.         ret.setNome(r.getNome());
  706.         ret.setDescrizione(r.getDescrizione());

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

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

  717.         return ret;
  718.     }

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

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

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

  767.         ret.setDescrizione(api.getDescrizione());
  768.         ret.setTipoInterfaccia(api.getTipoInterfaccia());
  769.         ret.setNome(api.getNome());
  770.         ret.setProfilo(env.profilo);    // TODO: In multitenant questo va cambiato al profilo relativo al tip del soggetto referente dell'as
  771.         ret.setSoggetto(api.getReferente());
  772.         ret.setVersione(api.getVersione());
  773.         ret.setReferente(api.getReferente());


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

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

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

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

  804.             int numeroTotaleServizi = accordiPorttypeList.size();
  805.             int numeroServiziAbilitati = 0;

  807.             for (PortType portType : accordiPorttypeList) {
  808.                 if(portType.sizeAzioneList()>0) {
  809.                     numeroServiziAbilitati ++;
  810.                 }   
  811.             }

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

  835.         ret.setStatoDescrizione(descrizioneStato);
  836.         ret.setStato(stato);

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

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

  858.         return ret;

  860.     }

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

  865.         ret.setNome(as.getNome());
  866.         ret.setDescrizione(as.getDescrizione());

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

  885.         ret.setVersione(as.getVersione());
  886.         ret.setReferente(as.getSoggettoReferente().getNome());

  888.         return ret; 
  889.     }


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

  900. }
Created with JaCoCo 0.8.8.202204050719