UrlInvocazioneAPI.java

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

  21. package org.openspcoop2.pdd.config;

  23. import java.io.Serializable;
  24. import java.util.ArrayList;
  25. import java.util.Collections;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  31. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  32. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  33. import org.openspcoop2.core.config.constants.RuoloContesto;
  34. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  36. import org.openspcoop2.core.constants.CostantiLabel;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.message.constants.ServiceBinding;
  39. import org.openspcoop2.protocol.engine.constants.Costanti;
  40. import org.openspcoop2.protocol.manifest.Context;
  41. import org.openspcoop2.protocol.manifest.WebEmptyContext;
  42. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  43. import org.openspcoop2.protocol.utils.PorteNamingUtils;
  44. import org.openspcoop2.utils.Utilities;
  45. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  46. import org.openspcoop2.utils.regexp.RegularExpressionEngine;

  48. /**
  49.  * UrlInvocazioneAPI
  50.  *
  51.  * @author Poli Andrea (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class UrlInvocazioneAPI implements Serializable {

  57.     /**
  58.      * 
  59.      */
  60.     private static final long serialVersionUID = 1L;
  61.     
  62.     private String baseUrl;
  63.     private String context;
  64.     
  65.     public String getBaseUrl() {
  66.         return this.baseUrl;
  67.     }
  68.     public void setBaseUrl(String baseUrl) {
  69.         this.baseUrl = baseUrl;
  70.     }
  71.     public String getContext() {
  72.         return this.context;
  73.     }
  74.     public void setContext(String context) {
  75.         this.context = context;
  76.     }
  77.     public String getUrl() {
  78.         if(this.baseUrl==null) {
  79.             return null;
  80.         }
  81.         return Utilities.buildUrl(this.baseUrl, this.context);
  82.     }

  84.     
  85.     
  86.     
  87.     // *** STATIC UTILITIES **
  88.     
  89.     public static UrlInvocazioneAPI getConfigurazioneUrlInvocazione(ConfigurazioneUrlInvocazione configurazioneUrlInvocazione, 
  90.             IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, 
  91.             String interfaceName, IDSoggetto soggettoOperativo,
  92.             List<String> tags, String canale) throws DriverConfigurazioneException{
  93.         return getConfigurazioneUrlInvocazione(configurazioneUrlInvocazione, 
  94.                 protocolFactory, ruolo, serviceBinding, 
  95.                 interfaceName, soggettoOperativo,
  96.                 tags, canale, true);
  97.     }
  98.     
  99.     public static UrlInvocazioneAPI getConfigurazioneUrlInvocazione(ConfigurazioneUrlInvocazione configurazioneUrlInvocazione, 
  100.             IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, 
  101.             String interfaceName, IDSoggetto soggettoOperativo,
  102.             List<String> tags, String canale, boolean analizeProxyPassRules) throws DriverConfigurazioneException{
  103.         
  104.         if(configurazioneUrlInvocazione==null) {
  105.             configurazioneUrlInvocazione = new ConfigurazioneUrlInvocazione();
  106.             initConfigurazioneProtocolloUrlInvocazione(configurazioneUrlInvocazione);
  107.         }
  108.         
  109.         // normalizzo interfaceName
  110.         String interfaceNameNormalizzata = interfaceName;
  111.         if(interfaceNameNormalizzata!=null) {
  112.             try {
  113.                 PorteNamingUtils utils = new PorteNamingUtils(protocolFactory);
  114.                 if( RuoloContesto.PORTA_DELEGATA.equals(ruolo) ) {
  115.                     interfaceNameNormalizzata = utils.normalizePD(interfaceName);
  116.                 }
  117.                 else {
  118.                     interfaceNameNormalizzata = utils.normalizePA(interfaceName);
  119.                 }
  120.             }catch(Exception e){
  121.                 protocolFactory.getLogger().debug("Normalizzazione interface name '"+interfaceName+"' non riuscita: "+e.getMessage(),e);
  122.             }
  123.         }
  124.         
  125.         // Regola di default
  126.         ConfigurazioneUrlInvocazioneRegola regolaDefault = getConfigurazioneUrlInvocazioneDefault(configurazioneUrlInvocazione, protocolFactory, ruolo, serviceBinding, interfaceNameNormalizzata); // default
  127.         
  128.         // Colleziono regole compatibili
  129.         ConfigurazioneUrlInvocazioneRegola regola = null;
  130.         if(analizeProxyPassRules) {
  131.             Map<String, ConfigurazioneUrlInvocazioneRegola> regole = new HashMap<>();
  132.             for (ConfigurazioneUrlInvocazioneRegola check : configurazioneUrlInvocazione.getRegolaList()) {
  133.                 String paddedNumber = String.format("%010d", check.getPosizione());
  134.                 regole.put(paddedNumber, check);
  135.             }
  136.             if(regole.size()>0) {
  137.                 List<String> posizioni = new ArrayList<>();
  138.                 posizioni.addAll(regole.keySet());
  139.                 Collections.sort(posizioni);
  140.                 for (String posizione : posizioni) {
  141.                     ConfigurazioneUrlInvocazioneRegola check = regole.get(posizione);
  142.                     try {
  143.                         /**System.out.println("ESAMINO REGOLA ALLA POSIZIONE '"+posizione+"'");*/
  144.                         String contesto = getContext(protocolFactory, ruolo, serviceBinding, interfaceNameNormalizzata);
  145.                         if(isMatchRegolaUrlInvocazione(check, protocolFactory, ruolo, serviceBinding, contesto, soggettoOperativo)) { 
  146.                             regola = processMatchRegolaUrlInvocazione(check, contesto,
  147.                                     tags, canale); // risolve eventuale match di espressioni regolari.
  148.                             break;
  149.                         }   
  150.                     }catch(Exception e) {
  151.                         protocolFactory.getLogger().error("Errore durante il processamento della regola-"+posizione+" '"+check.getNome()+"': "+e.getMessage(),e);
  152.                     }
  153.                 }
  154.             }
  155.         }
  156.         if(regola==null) {
  157.             regola = regolaDefault;
  158.         }
  159.         
  160.         UrlInvocazioneAPI url = new UrlInvocazioneAPI();
  161.         if(regola.getBaseUrl()!=null) {
  162.             url.setBaseUrl(regola.getBaseUrl());
  163.         }
  164.         else {
  165.             if( RuoloContesto.PORTA_DELEGATA.equals(ruolo) && configurazioneUrlInvocazione.getBaseUrlFruizione()!=null ) {
  166.                 url.setBaseUrl(configurazioneUrlInvocazione.getBaseUrlFruizione());
  167.             }
  168.             else {
  169.                 url.setBaseUrl(configurazioneUrlInvocazione.getBaseUrl());
  170.             }
  171.         }
  172.         url.setContext(regola.getContestoEsterno());
  173.         
  174.         return url;
  175.     }
  176.     
  177.     private static void initConfigurazioneProtocolloUrlInvocazione(ConfigurazioneUrlInvocazione configurazioneUrlInvocazione) throws DriverConfigurazioneException {
  178.         try {
  179.             if(configurazioneUrlInvocazione.getBaseUrl()==null) {
  180.                 configurazioneUrlInvocazione.setBaseUrl(CostantiConfigurazione.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_URL_INVOCAZIONE_PREFIX);
  181.             }
  182.             
  183.         }catch(Exception e) {
  184.             throw new DriverConfigurazioneException(e.getMessage(),e);
  185.         }
  186.     }
  187.     
  188.     private static ConfigurazioneUrlInvocazioneRegola getConfigurazioneUrlInvocazioneDefault(ConfigurazioneUrlInvocazione configurazioneUrlInvocazione, 
  189.             IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, String interfaceNameNormalizzata) throws DriverConfigurazioneException {
  190.     
  191.         try {
  192.             
  193.             if(configurazioneUrlInvocazione!=null) {
  194.                 // nop
  195.             }
  196.             
  197.             ConfigurazioneUrlInvocazioneRegola regola = new ConfigurazioneUrlInvocazioneRegola();
  198.             regola.setNome(CostantiConfigurazione.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_URL_INVOCAZIONE_DEFAULT_RULE_NAME);
  199.             regola.setPosizione(-1); // non serve, verrà usata questa regola
  200.             regola.setStato(StatoFunzionalita.ABILITATO);
  201.             regola.setDescrizione(CostantiConfigurazione.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_URL_INVOCAZIONE_DEFAULT_RULE_DESCRIPTION);
  202.             regola.setRegexpr(false);
  203.             regola.setRegola(""); // non serve, verrà usata questa regola per produrre la url di invocazione
  204.             
  205.             regola.setContestoEsterno(getContext(protocolFactory, ruolo, serviceBinding, interfaceNameNormalizzata));
  206.             
  207.             regola.setBaseUrl(null); // viene usata quella di default
  208.             regola.setProtocollo(protocolFactory.getProtocol());
  209.             regola.setRuolo(ruolo);
  210.             if(serviceBinding!=null) {
  211.                 regola.setServiceBinding(ServiceBinding.REST.equals(serviceBinding) ? org.openspcoop2.core.config.constants.ServiceBinding.REST : org.openspcoop2.core.config.constants.ServiceBinding.SOAP);
  212.             }       
  213.             
  214.             return regola;

  216.         }catch(Exception e) {
  217.             throw new DriverConfigurazioneException(e.getMessage(),e);
  218.         }
  219.     }
  220.     
  221.     private static boolean isMatchRegolaUrlInvocazione(ConfigurazioneUrlInvocazioneRegola check, 
  222.             IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, 
  223.             String contesto, IDSoggetto soggettoOperativoInterfaccia) throws DriverConfigurazioneException {
  224.         
  225.         if(StatoFunzionalita.DISABILITATO.equals(check.getStato())) {
  226.             return false;
  227.         }
  228.         
  229.         if(check.getProtocollo()!=null) {
  230.             if(protocolFactory==null) {
  231.                 return false;
  232.             }
  233.             if(!check.getProtocollo().equals(protocolFactory.getProtocol())) {
  234.                 return false;
  235.             }
  236.         }
  237.         
  238.         if(check.getRuolo()!=null) {
  239.             if(ruolo==null) {
  240.                 return false;
  241.             }
  242.             if(!check.getRuolo().equals(ruolo)) {
  243.                 return false;
  244.             }   
  245.         }
  246.         
  247.         if(check.getServiceBinding()!=null) {
  248.             if(serviceBinding==null) {
  249.                 return false;
  250.             }
  251.             if(!check.getServiceBinding().name().equals(serviceBinding.name())) {
  252.                 return false;
  253.             }   
  254.         }
  255.         
  256.         if(check.getSoggetto()!=null && check.getSoggetto().getTipo()!=null && check.getSoggetto().getNome()!=null) {
  257.             if(soggettoOperativoInterfaccia==null) {
  258.                 return false;
  259.             }
  260.             try {
  261.                 if(!check.getSoggetto().toIDSoggetto().equals(soggettoOperativoInterfaccia)) {
  262.                     return false;
  263.                 }
  264.             }catch(Exception e) {
  265.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  266.             }
  267.         }
  268.         
  269.         if(contesto==null) {
  270.             return false;
  271.         }
  272.         if(check.isRegexpr()) {
  273.             try {
  274.                 boolean isMatch = RegularExpressionEngine.isMatch(contesto, check.getRegola());
  275.                 if(isMatch) {
  276.                     return true;
  277.                 }
  278.                 if(contesto.startsWith("/") && contesto.length()>1) {
  279.                     isMatch = RegularExpressionEngine.isMatch(contesto.substring(1), check.getRegola());
  280.                     if(isMatch) {
  281.                         return true;
  282.                     }
  283.                 }
  284.                 return false;
  285.             }catch(RegExpNotFoundException notFound) {
  286.                 return  false;
  287.             }catch(Exception e) {
  288.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  289.             }
  290.         }
  291.         else {
  292.             String contestDaVerificare = contesto;
  293.             if(contesto.startsWith("/")) {
  294.                 if(!check.getRegola().startsWith("/")) {
  295.                     if(contesto.length()==1) {
  296.                         contestDaVerificare = "";
  297.                     }
  298.                     else {
  299.                         contestDaVerificare = contestDaVerificare.substring(1);
  300.                     }
  301.                 }
  302.             }
  303.             else {
  304.                 if(check.getRegola().startsWith("/")) {
  305.                     contestDaVerificare = "/"+contestDaVerificare;
  306.                 }
  307.             }
  308.             return contestDaVerificare.startsWith(check.getRegola());
  309.         }
  310.     }
  311.     
  312.     private static ConfigurazioneUrlInvocazioneRegola processMatchRegolaUrlInvocazione(ConfigurazioneUrlInvocazioneRegola regolaParam, String contestoParam,
  313.             List<String> tags, String canale) throws DriverConfigurazioneException {
  314.         
  315.         ConfigurazioneUrlInvocazioneRegola regola = (ConfigurazioneUrlInvocazioneRegola) regolaParam.clone();
  316.         
  317.         if(regola.isRegexpr()) {
  318.             try {
  319.                 String contestoDaUsarePerVerifica = contestoParam;
  320.                 boolean isMatch = RegularExpressionEngine.isMatch(contestoDaUsarePerVerifica, regola.getRegola());
  321.                 if(!isMatch &&
  322.                     contestoDaUsarePerVerifica.startsWith("/") && contestoDaUsarePerVerifica.length()>1) {
  323.                     contestoDaUsarePerVerifica = contestoDaUsarePerVerifica.substring(1);
  324.                 }
  325.                 
  326.                 List<String> list = null;
  327.                 try {
  328.                     list = RegularExpressionEngine.getAllStringMatchPattern(contestoDaUsarePerVerifica, regola.getRegola());
  329.                 }catch(RegExpNotFoundException notFound) {
  330.                     if(!RegularExpressionEngine.isMatch(contestoDaUsarePerVerifica, regola.getRegola())) {
  331.                         throw notFound; // altrimenti l'espressione regolare ha un match senza però  avere condizioni () per estrarre informazioni tramite gruppi.
  332.                     }
  333.                 }
  334.                 String newContesto = regola.getContestoEsterno();
  335.                 if(newContesto==null) {
  336.                     newContesto = "";
  337.                 }
  338.                 String baseUrl = regola.getBaseUrl();
  339.                 if(list!=null) {
  340.                     for (int i = 0; i < list.size(); i++) {
  341.                         String found = list.get(i);
  342.                         if(found==null) {
  343.                             found = "";
  344.                         }
  345.                         
  346.                         String key = "${"+i+"}";
  347.                         while(newContesto.contains(key)) {
  348.                             newContesto = newContesto.replace(key, found);
  349.                         }
  350.                         if(baseUrl!=null) {
  351.                             while(baseUrl.contains(key)) {
  352.                                 baseUrl = baseUrl.replace(key, found);
  353.                             }   
  354.                         }
  355.                     }
  356.                 }
  357.                                 
  358.                 regola.setContestoEsterno(newContesto);
  359.                 regola.setBaseUrl(baseUrl);
  360.             }
  361.             /**catch(RegExpNotFoundException notFound) { NON dovrebbe succedere, gestito prima con l'if
  362.                 return  null; 
  363.             }*/
  364.             catch(Exception e) {
  365.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  366.             }
  367.         }
  368.         
  369.         // tags
  370.         if(tags!=null && !tags.isEmpty()) {
  371.             
  372.             String newContesto = regola.getContestoEsterno();
  373.             if(newContesto==null) {
  374.                 newContesto = "";
  375.             }
  376.             String baseUrl = regola.getBaseUrl();
  377.             
  378.             for (int i = 0; i < tags.size(); i++) {
  379.                 String found = tags.get(i);
  380.                 if(found==null) {
  381.                     found = "";
  382.                 }
  383.                 
  384.                 if(i==0) {
  385.                     String key = "${tag}";
  386.                     while(newContesto.contains(key)) {
  387.                         newContesto = newContesto.replace(key, found);
  388.                     }
  389.                     if(baseUrl!=null) {
  390.                         while(baseUrl.contains(key)) {
  391.                             baseUrl = baseUrl.replace(key, found);
  392.                         }   
  393.                     }
  394.                 }
  395.                 
  396.                 String key = "${tag["+i+"]}";
  397.                 while(newContesto.contains(key)) {
  398.                     newContesto = newContesto.replace(key, found);
  399.                 }
  400.                 if(baseUrl!=null) {
  401.                     while(baseUrl.contains(key)) {
  402.                         baseUrl = baseUrl.replace(key, found);
  403.                     }   
  404.                 }
  405.             }
  406.             
  407.             regola.setContestoEsterno(newContesto);
  408.             regola.setBaseUrl(baseUrl);
  409.         }
  410.         
  411.         // canale
  412.         if(canale!=null) {
  413.             String newContesto = regola.getContestoEsterno();
  414.             if(newContesto==null) {
  415.                 newContesto = "";
  416.             }
  417.             String baseUrl = regola.getBaseUrl();
  418.             
  419.             String key = "${canale}";
  420.             while(newContesto.contains(key)) {
  421.                 newContesto = newContesto.replace(key, canale);
  422.             }
  423.             if(baseUrl!=null) {
  424.                 while(baseUrl.contains(key)) {
  425.                     baseUrl = baseUrl.replace(key, canale);
  426.                 }   
  427.             }
  428.                 
  429.             regola.setContestoEsterno(newContesto);
  430.             regola.setBaseUrl(baseUrl);
  431.         }
  432.         
  433.         return regola;
  434.         
  435.         
  436.     }
  437.     
  438.     
  439.     private static String getContext(IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, String interfaceNameNormalizzata) throws DriverConfigurazioneException {
  440.     
  441.         try {
  442.             boolean trasparente = false;
  443.             if(protocolFactory!=null) {
  444.                 trasparente = Costanti.TRASPARENTE_PROTOCOL_NAME.equals(protocolFactory.getProtocol());
  445.             }
  446.             boolean forceContextWithoutBinding = false;
  447.             if(trasparente) {
  448.                 forceContextWithoutBinding = true; // altrimenti vengono usati api-rest e api-soap
  449.             }
  450.             
  451.             String contextWithoutBinding = null;
  452.             String contextWithRestBinding = null;
  453.             String contextWithSoapBinding = null;
  454.             if(protocolFactory!=null && protocolFactory.getManifest().getWeb().getEmptyContext()!=null) {
  455.                 WebEmptyContext ctx = protocolFactory.getManifest().getWeb().getEmptyContext();
  456.                 if(ctx.getBinding()==null) {
  457.                     if(contextWithoutBinding==null) {
  458.                         contextWithoutBinding = "";
  459.                     }
  460.                 }
  461.                 else if(org.openspcoop2.protocol.manifest.constants.ServiceBinding.REST.equals(ctx.getBinding())) {
  462.                     if(contextWithRestBinding==null) {
  463.                         contextWithRestBinding = "";
  464.                     }
  465.                 }
  466.                 else if(org.openspcoop2.protocol.manifest.constants.ServiceBinding.SOAP.equals(ctx.getBinding()) &&
  467.                     contextWithSoapBinding==null) {
  468.                     contextWithSoapBinding = "";
  469.                 }
  470.             }
  471.             if(protocolFactory!=null && protocolFactory.getManifest().getWeb().sizeContextList()>0) {
  472.                 for (Context ctx : protocolFactory.getManifest().getWeb().getContextList()) {
  473.                     if(ctx.getBinding()==null) {
  474.                         if(contextWithoutBinding==null) {
  475.                             contextWithoutBinding = ctx.getName();
  476.                         }
  477.                     }
  478.                     else if(org.openspcoop2.protocol.manifest.constants.ServiceBinding.REST.equals(ctx.getBinding())) {
  479.                         if(contextWithRestBinding==null) {
  480.                             contextWithRestBinding = ctx.getName();
  481.                         }
  482.                     }
  483.                     else if(org.openspcoop2.protocol.manifest.constants.ServiceBinding.SOAP.equals(ctx.getBinding()) &&
  484.                         contextWithSoapBinding==null) {
  485.                         contextWithSoapBinding = ctx.getName();
  486.                     }
  487.                 }
  488.             }
  489.             
  490.             // Assegno i contesti se non trovati altri.
  491.             if(contextWithRestBinding==null || (forceContextWithoutBinding && contextWithoutBinding!=null)) {
  492.                 contextWithRestBinding = contextWithoutBinding;
  493.             }
  494.             if(contextWithSoapBinding==null || (forceContextWithoutBinding && contextWithoutBinding!=null)) {
  495.                 contextWithSoapBinding = contextWithoutBinding;
  496.             }
  497.             if(contextWithoutBinding==null) {
  498.                 throw new DriverConfigurazioneException("Contesto senza uno specifico binding non indicato");
  499.             }
  500.             
  501.             String contestoEsterno = null;
  502.             if(serviceBinding!=null) {
  503.                 switch (serviceBinding) {
  504.                 case REST:
  505.                     contestoEsterno = RuoloContesto.PORTA_DELEGATA.equals(ruolo) ? 
  506.                             CostantiConfigurazione.getDefaultValueParametroConfigurazioneProtocolloPrefixUrlInvocazionePd(contextWithRestBinding) :
  507.                             CostantiConfigurazione.getDefaultValueParametroConfigurazioneProtocolloPrefixUrlInvocazionePa(contextWithRestBinding);
  508.                     break;
  509.                 case SOAP:
  510.                     contestoEsterno = RuoloContesto.PORTA_DELEGATA.equals(ruolo) ? 
  511.                             CostantiConfigurazione.getDefaultValueParametroConfigurazioneProtocolloPrefixUrlInvocazionePd(contextWithSoapBinding) :
  512.                             CostantiConfigurazione.getDefaultValueParametroConfigurazioneProtocolloPrefixUrlInvocazionePa(contextWithSoapBinding);
  513.                     break;
  514.                 }
  515.             }
  516.             else {
  517.                 contestoEsterno = RuoloContesto.PORTA_DELEGATA.equals(ruolo) ? 
  518.                         CostantiConfigurazione.getDefaultValueParametroConfigurazioneProtocolloPrefixUrlInvocazionePd(contextWithoutBinding) :
  519.                         CostantiConfigurazione.getDefaultValueParametroConfigurazioneProtocolloPrefixUrlInvocazionePa(contextWithoutBinding);
  520.             }
  521.             
  522.             if(contestoEsterno!=null) {
  523.                 if(CostantiLabel.TRASPARENTE_PROTOCOL_NAME.equalsIgnoreCase(protocolFactory.getProtocol())) {
  524.                     if(RuoloContesto.PORTA_APPLICATIVA.equals(ruolo)) {
  525.                         if(contestoEsterno.endsWith("in/")) {
  526.                             contestoEsterno = contestoEsterno.substring(0, contestoEsterno.length()-"in/".length());
  527.                         }
  528.                         else if(contestoEsterno.endsWith("in")) {
  529.                             contestoEsterno = contestoEsterno.substring(0, contestoEsterno.length()-"in".length());
  530.                         }
  531.                     }
  532.                 }
  533.                 else if(CostantiLabel.SDI_PROTOCOL_NAME.equalsIgnoreCase(protocolFactory.getProtocol()) &&
  534.                     RuoloContesto.PORTA_DELEGATA.equals(ruolo)) {
  535.                     if(contestoEsterno.endsWith("out/")) {
  536.                         contestoEsterno = contestoEsterno + "xml2soap/";
  537.                     }
  538.                     else if(contestoEsterno.endsWith("out")) {
  539.                         contestoEsterno = contestoEsterno + "/xml2soap/";
  540.                     }
  541.                 }
  542.             }
  543.             
  544.             
  545.             boolean useInterfaceName = false;
  546.             if(RuoloContesto.PORTA_APPLICATIVA.equals(ruolo)) {
  547.                 useInterfaceName = protocolFactory.createProtocolIntegrationConfiguration().useInterfaceNameInImplementationInvocationURL(serviceBinding);
  548.             }
  549.             else {
  550.                 useInterfaceName = protocolFactory.createProtocolIntegrationConfiguration().useInterfaceNameInSubscriptionInvocationURL(serviceBinding);
  551.             }
  552.                         
  553.             if(useInterfaceName && interfaceNameNormalizzata!=null && !"".equals(interfaceNameNormalizzata)) {
  554.                 if(contestoEsterno!=null) {
  555.                     contestoEsterno = contestoEsterno + "/" +interfaceNameNormalizzata;
  556.                 }
  557.                 else {
  558.                     contestoEsterno = interfaceNameNormalizzata;
  559.                 }
  560.             }
  561.             
  562.             if(contestoEsterno!=null) {
  563.                 while(contestoEsterno.contains("//")) {
  564.                     contestoEsterno = contestoEsterno.replace("//", "/");
  565.                 }
  566.             }
  567.                         
  568.             if(contestoEsterno!=null &&
  569.                 !contestoEsterno.startsWith("/")) {
  570.                 contestoEsterno = "/"+contestoEsterno;
  571.             }
  572.             
  573.             return contestoEsterno;
  574.             
  575.         }catch(Exception e) {
  576.             throw new DriverConfigurazioneException(e.getMessage(),e);
  577.         }
  578.     }
  579. }
Created with JaCoCo 0.8.8.202204050719