OperationFinder.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.protocol.engine.mapping;

  22. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  23. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  24. import org.openspcoop2.core.id.IDServizio;
  25. import org.openspcoop2.core.id.IDSoggetto;
  26. import org.openspcoop2.core.registry.Operation;
  27. import org.openspcoop2.core.registry.PortType;
  28. import org.openspcoop2.core.registry.Resource;
  29. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  30. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  31. import org.openspcoop2.core.registry.wsdl.WSDLValidatorConfig;
  32. import org.openspcoop2.message.MessageUtils;
  33. import org.openspcoop2.message.OpenSPCoop2Message;
  34. import org.openspcoop2.message.constants.MessageType;
  35. import org.openspcoop2.message.constants.ServiceBinding;
  36. import org.openspcoop2.message.rest.RestUtilities;
  37. import org.openspcoop2.message.soap.SoapUtils;
  38. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  39. import org.openspcoop2.protocol.engine.constants.ModalitaIdentificazioneAzione;
  40. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  41. import org.openspcoop2.protocol.sdk.Busta;
  42. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  43. import org.openspcoop2.protocol.sdk.constants.InformationApiSource;
  44. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  45. import org.openspcoop2.protocol.utils.PorteNamingUtils;
  46. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  47. import org.openspcoop2.utils.rest.api.ApiOperation;
  48. import org.openspcoop2.utils.transport.TransportRequestContext;
  49. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  50. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  51. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  52. import org.slf4j.Logger;
  53. import org.w3c.dom.Element;

  55. /**
  56.  * OperationFinder
  57.  *
  58.  * @author Andrea Poli (apoli@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */
  62. public class OperationFinder {
  63.     
  64.     private OperationFinder() {}

  66.     private static String getPrefixIdentificazione(ModalitaIdentificazioneAzione modalitaIdentificazione) {
  67.         return "Identificazione '"+modalitaIdentificazione.getValue()+"' ";
  68.     }
  69.     
  70.     public static String getAzione(RegistroServiziManager registroServiziManager,TransportRequestContext transportContext, RequestInfo requestInfo,
  71.             OpenSPCoop2Message message, OpenSPCoop2MessageSoapStreamReader soapStreamReader, 
  72.             IDSoggetto soggettoErogatore, IDServizio idServizio,
  73.             boolean readFirstHeaderIntegrazione, String azioneHeaderIntegrazione, 
  74.             IProtocolFactory<?> protocolFactory,
  75.             ModalitaIdentificazioneAzione modalitaIdentificazione, String pattern, 
  76.             boolean forceRegistryBased, boolean forcePluginBased,
  77.             Logger log, boolean portaApplicativa,
  78.             boolean bufferMessageReadOnly , String idTransazione,
  79.             WSDLValidatorConfig config) throws DriverConfigurazioneException, IdentificazioneDinamicaException { 
  80.         
  81.         try{

  83.             if(soggettoErogatore!=null) {
  84.                  // nop
  85.             }
  86.             
  87.             // Recupero Lista di Azioni
  88.             /**
  89.             List<String> listaAzioni = new ArrayList<>();
  90.             boolean rest = false;
  91.             try {
  92.                 AccordoServizioParteSpecifica asps = registroServiziManager.getAccordoServizioParteSpecifica(idServizio, null, false);
  93.                 AccordoServizioParteComune aspc = registroServiziManager.getAccordoServizioParteComune(IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune()), null, false);
  94.                 if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(aspc.getServiceBinding())) {
  95.                     rest = true;
  96.                     for (Resource r : aspc.getResourceList()) {
  97.                         listaAzioni.add(r.getNome());
  98.                     }
  99.                 }
  100.                 else {
  101.                     if(asps.getPortType()==null) {
  102.                         for (Azione a : aspc.getAzioneList()) {
  103.                             listaAzioni.add(a.getNome());
  104.                         }
  105.                     }
  106.                     else {
  107.                         for (PortType pt: aspc.getPortTypeList()) {
  108.                             if(pt.getNome().equals(asps.getPortType())) {
  109.                                 for (Operation a : pt.getAzioneList()) {
  110.                                     listaAzioni.add(a.getNome());
  111.                                 }
  112.                                 break;
  113.                             }
  114.                         }
  115.                     }
  116.                 }
  117.             }catch(Throwable t) {
  118.                 // ignoro errori, li sollevo in altri posti
  119.             }*/
  120.             
  121.             boolean registryBased = false;
  122.             boolean pluginBased = false;
  123.             
  124.             String azione = null;
  125.             Exception eAzione = null;
  126.             try{
  127.                 if(ModalitaIdentificazioneAzione.STATIC.equals(modalitaIdentificazione)){
  128.                     // STATIC-BASED
  129.                     azione = idServizio.getAzione();
  130.                 }
  131.                 else{
  132.                     if(readFirstHeaderIntegrazione && azioneHeaderIntegrazione!=null){
  133.                         // INTEGRATIONMANAGER INPUT
  134.                         azione = azioneHeaderIntegrazione;
  135.                     }
  136.                     else{
  137.                         if(ModalitaIdentificazioneAzione.URL_BASED.equals(modalitaIdentificazione)){
  138.                             // URL-BASED
  139.                             String urlInvocazionePD = transportContext.getUrlInvocazione_formBased();
  140.                             azione = RegularExpressionEngine.getStringFindPattern(urlInvocazionePD, pattern); // Sostituito Match con Find per applicare l'espressione regolare che risolve il bug OP-1590
  141.                             if(ServiceBinding.REST.equals(message.getServiceBinding())){
  142.                                 throw new DriverConfigurazioneNotFound(getPrefixIdentificazione(modalitaIdentificazione)+
  143.                                         "non supportata per il service binding '"+ServiceBinding.REST+"'");
  144.                             }
  145.                         }                       
  146.                         else if(ModalitaIdentificazioneAzione.HEADER_BASED.equals(modalitaIdentificazione)){
  147.                             // HEADER-BASED
  148.                             azione = transportContext.getHeaderFirstValue(pattern);
  149.                         }
  150.                         else if(ModalitaIdentificazioneAzione.CONTENT_BASED.equals(modalitaIdentificazione)){
  151.                             // CONTENT-BASED
  152.                             if(message==null){
  153.                                 throw new DriverConfigurazioneNotFound("Messaggio non fornito");
  154.                             }
  155.                             AbstractXPathExpressionEngine xPathEngine = null;
  156.                             Element element = null;
  157.                             String elementJson = null;
  158.                             boolean checkSoapBodyEmpty = false; // devo poter fare xpath anche su soapBody empty
  159.                             if(message!=null) {
  160.                                 element = MessageUtils.getContentElement(message, checkSoapBodyEmpty, bufferMessageReadOnly, idTransazione);
  161.                                 elementJson = MessageUtils.getContentString(message, bufferMessageReadOnly, idTransazione);
  162.                             }
  163.                             if(element!=null) {
  164.                                 xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(message.getFactory());
  165.                                 azione = AbstractXPathExpressionEngine.extractAndConvertResultAsString(element, xPathEngine, pattern,  log);
  166.                             }
  167.                             else if(elementJson!=null){
  168.                                 azione = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(elementJson, pattern, log);
  169.                             }
  170.                             else{
  171.                                 throw new DriverConfigurazioneNotFound(getPrefixIdentificazione(modalitaIdentificazione)+"non supportata per il message-type '"+message.getMessageType()+"'");
  172.                             }
  173.                         }
  174.                         else if(ModalitaIdentificazioneAzione.INPUT_BASED.equals(modalitaIdentificazione)){
  175.                             // INPUT-BASED
  176.                             if(azioneHeaderIntegrazione!=null){
  177.                                 azione = azioneHeaderIntegrazione;
  178.                             }
  179.                             else{
  180.                                 throw new DriverConfigurazioneNotFound("Azione non indicata negli header di integrazione");
  181.                             }
  182.                         }
  183.                         else if(ModalitaIdentificazioneAzione.SOAP_ACTION_BASED.equals(modalitaIdentificazione)){
  184.                             // SOAP-ACTION-BASED
  185.                             if(message!=null && ServiceBinding.REST.equals(message.getServiceBinding())){
  186.                                 throw new DriverConfigurazioneNotFound(getPrefixIdentificazione(modalitaIdentificazione)+
  187.                                         "non supportata per il service binding '"+ServiceBinding.REST+"'");
  188.                             }
  189.                             if(message!=null){
  190.                                 azione = message.castAsSoap().getSoapAction();
  191.                             }
  192.                             else{
  193.                                 // provo una soluzione veloce di vedere se è presente nell'header di trasporto o nel content-type
  194.                                 // non so che tipo di message type possiedo
  195.                                 azione = getSoapAction(transportContext);
  196.                             }
  197.                             String azioneNonRipulita = azione;
  198.                             if(azione!=null){
  199.                                 azione = azione.trim();
  200.                                 // Nota: la soap action potrebbe essere quotata con "" 
  201.                                 if(azione.startsWith("\"")){
  202.                                     azione = azione.substring(1);
  203.                                 }
  204.                                 if(azione.endsWith("\"")){
  205.                                     azione = azione.substring(0,(azione.length()-1));
  206.                                 }   
  207.                             }
  208.                             
  209.                             // Provo a fare la traduzione tramite soapAction registrata nell'accordo
  210.                             if(azioneNonRipulita!=null || azione!=null) {
  211.                                 org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper wrapper = registroServiziManager.getWsdlAccordoServizio(idServizio,InformationApiSource.SAFE_SPECIFIC_REGISTRY,false,false, requestInfo);
  212.                                 if(wrapper!=null){
  213.                                     for (int i = 0; i < wrapper.sizePortTypeList(); i++) {
  214.                                         PortType pt = wrapper.getPortType(i);
  215.                                         if(wrapper.getNomePortType()!=null &&
  216.                                             !pt.getNome().equals(wrapper.getNomePortType())){
  217.                                             continue;
  218.                                         }
  219.                                         for (int j = 0; j < pt.sizeAzioneList(); j++) {
  220.                                             Operation op = pt.getAzione(j);
  221.                                             if(
  222.                                                 (azioneNonRipulita!=null && azioneNonRipulita.equals(op.getSoapAction())) 
  223.                                                 ||
  224.                                                 (azione!=null && azione.equals(op.getSoapAction()))
  225.                                                 ) {
  226.                                                 /**System.out.println("RESOLVE 1 ["+azioneNonRipulita+"]");*/
  227.                                                 /**System.out.println("RESOLVE 2 ["+azione+"]");*/
  228.                                                 azione = op.getNome();
  229.                                                 break;
  230.                                             }
  231.                                         }
  232.                                     }
  233.                                 }
  234.                             }
  235.                             
  236.                             if(azione!=null &&
  237.                                 "".equals(azione)){
  238.                                 azione = null;
  239.                                 throw new DriverConfigurazioneNotFound("SoapAction vuota ("+message.castAsSoap().getSoapAction()+") non è utilizzabile con una identificazione '"+
  240.                                         ModalitaIdentificazioneAzione.SOAP_ACTION_BASED.getValue()+"'");
  241.                             }
  242.                             
  243.                         }
  244.                         else if(ModalitaIdentificazioneAzione.INTERFACE_BASED.equals(modalitaIdentificazione)){
  245.                             // INTERFACE-BASED
  246.                             registryBased = true;
  247.                             OperationFinder.checkIDServizioPerRiconoscimentoAzione(idServizio, modalitaIdentificazione);
  248.                             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding = registroServiziManager.getServiceBinding(idServizio, requestInfo);
  249.                             if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(serviceBinding)){
  250.                                 azione = OperationFinder.searchOperationByWsdlInRequestMessage(message, soapStreamReader, requestInfo, registroServiziManager, idServizio, log,
  251.                                         config);
  252.                             }
  253.                             else {
  254.                                 azione = OperationFinder.searchOperationByRestInRequestMessage(transportContext, requestInfo, registroServiziManager, idServizio, log, 
  255.                                         protocolFactory, portaApplicativa);
  256.                             }
  257.                         }
  258.                         else if(ModalitaIdentificazioneAzione.PROTOCOL_BASED.equals(modalitaIdentificazione)){
  259.                             // PROTOCOL-BASED
  260.                             pluginBased = true;
  261.                             if(idServizio.getAzione()!=null){
  262.                                 // gia localizzata in precedenza
  263.                                 azione = idServizio.getAzione();
  264.                             }
  265.                             else{
  266.                                 OpenSPCoop2Message msgAnalizyProtocol = message;
  267.                                 if(message==null && soapStreamReader!=null) {
  268.                                     msgAnalizyProtocol=soapStreamReader.getHeader_OpenSPCoop2Message();
  269.                                 }
  270.                                 if(msgAnalizyProtocol==null){
  271.                                     throw new DriverConfigurazioneNotFound("Messaggio non fornito");
  272.                                 }
  273.                                 Busta busta = protocolFactory.createValidazioneSintattica(null).getBusta_senzaControlli(msgAnalizyProtocol);
  274.                                 if(busta!=null){
  275.                                     azione = busta.getAzione();
  276.                                 }
  277.                             }
  278.                         }
  279.                     }
  280.                 }
  281.             }catch(Exception e){
  282.                 eAzione = e;
  283.             }
  284.             
  285.             // Se non ho riconosciuto una azione, provo con la modalita' wsdlBased se e' abilitata.
  286.             if(azione==null && forceRegistryBased && !registryBased ){
  287.                 azione = getActionByInterface(log,
  288.                         transportContext, idServizio, modalitaIdentificazione,
  289.                         registroServiziManager, requestInfo, 
  290.                         message, soapStreamReader,
  291.                         protocolFactory,
  292.                         portaApplicativa,
  293.                         config);
  294.             }
  295.             // Se non ho riconosciuto una azione, provo con la modalita' pluginBased se e' abilitata.
  296.             if(azione==null && forcePluginBased && !pluginBased ){
  297.                 azione = getActionByPlugin(log,
  298.                         idServizio,
  299.                         message, soapStreamReader,
  300.                         protocolFactory);
  301.             }
  302.             // Se non ho riconosciuto una azione a questo punto, e durante il processo standard di riconoscimento era stato sollevata una eccezione
  303.             // viene rilanciato
  304.             if(azione==null && eAzione!=null)
  305.                 throw new IdentificazioneDinamicaException(eAzione.getMessage(),eAzione);

  307.             
  308.             return azione;

  310.         }catch(IdentificazioneDinamicaException e){
  311.             throw e;
  312.         }
  313.         catch(Exception e){
  314.             throw new DriverConfigurazioneException(e.getMessage(),e);
  315.         }

  317.     }
  318.     
  319.     private static String getSoapAction(TransportRequestContext transportContext) {
  320.         String azione = null;
  321.         try{
  322.             azione = SoapUtils.getSoapAction(transportContext, MessageType.SOAP_11, transportContext.getContentType());
  323.         }catch(Exception e){
  324.             // ignore
  325.         }
  326.         if(azione==null){
  327.             try{
  328.                 azione = SoapUtils.getSoapAction(transportContext, MessageType.SOAP_12, transportContext.getContentType());
  329.             }catch(Exception e){
  330.                 // ignore
  331.             }   
  332.         }
  333.         return azione;
  334.     }
  335.     
  336.     private static String getActionByInterface(Logger log,
  337.             TransportRequestContext transportContext, IDServizio idServizio, ModalitaIdentificazioneAzione modalitaIdentificazione,
  338.             RegistroServiziManager registroServiziManager, RequestInfo requestInfo, 
  339.             OpenSPCoop2Message message, OpenSPCoop2MessageSoapStreamReader soapStreamReader,
  340.             IProtocolFactory<?> protocolFactory,
  341.             boolean portaApplicativa,
  342.             WSDLValidatorConfig config) {
  343.         String azione = null;
  344.         try{
  345.             OperationFinder.checkIDServizioPerRiconoscimentoAzione(idServizio, modalitaIdentificazione);
  346.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding = registroServiziManager.getServiceBinding(idServizio, requestInfo);
  347.             if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(serviceBinding)){
  348.                 azione = OperationFinder.searchOperationByWsdlInRequestMessage(message, soapStreamReader, requestInfo, registroServiziManager, idServizio, log,
  349.                         config);
  350.             }
  351.             else{
  352.                 azione = OperationFinder.searchOperationByRestInRequestMessage(transportContext, requestInfo, registroServiziManager, idServizio, log, 
  353.                         protocolFactory, portaApplicativa);
  354.             }
  355.         }catch(Exception eForceRegistry){
  356.             log.debug("Riconoscimento forzato dell'azione non riuscito: "+eForceRegistry.getMessage(),eForceRegistry);
  357.         }
  358.         return azione;
  359.     }
  360.     
  361.     public static String searchOperationByWsdlInRequestMessage(OpenSPCoop2Message msg, OpenSPCoop2MessageSoapStreamReader soapStreamReaderParam, RequestInfo requestInfo, RegistroServiziManager registroServiziReader,IDServizio idServizio,Logger log,
  362.             WSDLValidatorConfig config) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  363.         return searchOperationByWsdl(true, msg, soapStreamReaderParam, requestInfo, registroServiziReader, idServizio, log,
  364.                 config);
  365.     }
  366.     /**public static String searchOperationByWsdlInResponseMessage(OpenSPCoop2Message msg, RequestInfo requestInfo, RegistroServiziManager registroServiziReader,IDServizio idServizio,Logger log,
  367.         boolean rpcAcceptRootElementUnqualified) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  368.         return searchOperationByWsdl(false, msg, requestInfo, registroServiziReader, idServizio, log,
  369.                 rpcAcceptRootElementUnqualified);
  370.     }*/
  371.     private static String searchOperationByWsdl(boolean isRichiesta,OpenSPCoop2Message msg, OpenSPCoop2MessageSoapStreamReader soapStreamReaderParam, RequestInfo requestInfo, RegistroServiziManager registroServiziReader,IDServizio idServizio,Logger log,
  372.             WSDLValidatorConfig config) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  373.         org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper wrapper = registroServiziReader.getWsdlAccordoServizio(idServizio,InformationApiSource.SAFE_SPECIFIC_REGISTRY,false,false,requestInfo);
  374.         org.openspcoop2.core.registry.wsdl.AccordoServizioWrapperUtilities wrapperUtilities = 
  375.                 new org.openspcoop2.core.registry.wsdl.AccordoServizioWrapperUtilities(log,wrapper);
  376.         return wrapperUtilities.searchOperationName(isRichiesta, wrapper.getNomePortType(), msg, soapStreamReaderParam, config);
  377.     }
  378.     
  379.     public static String searchOperationByRestInRequestMessage(TransportRequestContext transportContext, RequestInfo requestInfo, RegistroServiziManager registroServiziReader,IDServizio idServizio,Logger log,
  380.             IProtocolFactory<?> protocolFactory, boolean portaApplicativa) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  381.         
  382.         String normalizedInterfaceName = null;
  383.         try {
  384.             if(transportContext.getInterfaceName()!=null) {
  385.                 PorteNamingUtils namingUtils = new PorteNamingUtils(protocolFactory);
  386.                 if(portaApplicativa){
  387.                     normalizedInterfaceName = namingUtils.normalizePA(transportContext.getInterfaceName());
  388.                 }
  389.                 else {
  390.                     normalizedInterfaceName = namingUtils.normalizePD(transportContext.getInterfaceName());
  391.                 }
  392.             }
  393.         }catch(Exception e) {
  394.             throw new DriverRegistroServiziException(e.getMessage(),e);
  395.         }
  396.         String path = RestUtilities.getUrlWithoutInterface(transportContext, normalizedInterfaceName);
  397.         HttpRequestMethod httpMethod = HttpRequestMethod.valueOf(transportContext.getRequestType());
  398.         
  399.         try {
  400.             org.openspcoop2.core.registry.rest.AccordoServizioWrapper wrapper = registroServiziReader.getRestAccordoServizio(idServizio,InformationApiSource.SAFE_SPECIFIC_REGISTRY,false,false,false, requestInfo);
  401.             ApiOperation op = wrapper.getApi().findOperation(httpMethod, path);
  402.             if(op!=null) {
  403.                 // Il path nella 'ApiOperation è normalizzato come sul registro
  404.                 for (int i = 0; i < wrapper.getAccordoServizio().sizeResourceList(); i++) {
  405.                     Resource r = wrapper.getAccordoServizio().getResource(i);
  406.                     
  407.                     if(r.getMethod()==null) {
  408.                         if(op.getHttpMethod()!=null) {
  409.                             continue;
  410.                         }
  411.                     }
  412.                     else {
  413.                         if(op.getHttpMethod()==null) {
  414.                             continue;
  415.                         }
  416.                         if(!r.getMethod().name().equals(op.getHttpMethod().name())){
  417.                             continue;
  418.                         }
  419.                     }
  420.                     
  421.                     if(r.getPath()==null) {
  422.                         if(op.getPath()!=null) {
  423.                             continue;
  424.                         }
  425.                     }
  426.                     else {
  427.                         String rPath = r.getPath();
  428.                         String opPath = op.getPath();
  429.                         if(rPath!=null && rPath.length()>1 && rPath.endsWith("/")) {
  430.                             rPath = rPath.substring(0,rPath.length()-1);
  431.                         }
  432.                         if(opPath!=null && opPath.length()>1 && opPath.endsWith("/")) {
  433.                             opPath = opPath.substring(0,opPath.length()-1);
  434.                         }
  435.                         if(rPath!=null && !rPath.equals(opPath)){
  436.                             continue;
  437.                         }
  438.                     }
  439.                     
  440.                     return r.getNome();
  441.                     
  442.                 }
  443.             }
  444.         }catch(Exception e) {
  445.             throw new DriverRegistroServiziException(e.getMessage(),e);
  446.         }
  447.         
  448.         return null;
  449.     }
  450.     
  451.     private static String getActionByPlugin(Logger log,
  452.             IDServizio idServizio,
  453.             OpenSPCoop2Message message, OpenSPCoop2MessageSoapStreamReader soapStreamReader,
  454.             IProtocolFactory<?> protocolFactory) {
  455.         String azione = null;
  456.         try{
  457.             if(idServizio.getAzione()!=null){
  458.                 // gia localizzata in precedenza
  459.                 azione = idServizio.getAzione();
  460.             }
  461.             else{
  462.                 OpenSPCoop2Message msgAnalizyProtocol = message;
  463.                 if(message==null && soapStreamReader!=null) {
  464.                     msgAnalizyProtocol=soapStreamReader.getHeader_OpenSPCoop2Message();
  465.                 }
  466.                 if(msgAnalizyProtocol!=null){
  467.                     Busta busta = protocolFactory.createValidazioneSintattica(null).getBusta_senzaControlli(msgAnalizyProtocol);
  468.                     if(busta!=null){
  469.                         azione = busta.getAzione();
  470.                     }
  471.                 }
  472.             }
  473.         }catch(Exception eForcePlugin){
  474.             log.debug("Riconoscimento forzato dell'azione non riuscito: "+eForcePlugin.getMessage(),eForcePlugin);
  475.         }
  476.         return azione;
  477.     }
  478.     
  479.     private static void checkIDServizioPerRiconoscimentoAzione(IDServizio idServizio, ModalitaIdentificazioneAzione modalitaIdentificazione) throws DriverConfigurazioneException{
  480.         String suffixError = " (necessari per procedere con la modalità di identificazione "+modalitaIdentificazione+" dell'azione)";
  481.         if(idServizio==null){
  482.             throw new DriverConfigurazioneException("Dati del servizio non trovati"+suffixError);
  483.         }
  484.         if(idServizio.getSoggettoErogatore()==null){
  485.             throw new DriverConfigurazioneException("Dati del soggetto erogatore del servizio non trovati"+suffixError);
  486.         }
  487.         if(idServizio.getSoggettoErogatore().getTipo()==null){
  488.             throw new DriverConfigurazioneException("Tipo soggetto erogatore del servizio non trovato"+suffixError);
  489.         }
  490.         if(idServizio.getSoggettoErogatore().getNome()==null){
  491.             throw new DriverConfigurazioneException("Nome soggetto erogatore del servizio non trovato"+suffixError);
  492.         }
  493.         if(idServizio.getTipo()==null){
  494.             throw new DriverConfigurazioneException("Tipo servizio non trovato"+suffixError);
  495.         }
  496.         if(idServizio.getNome()==null){
  497.             throw new DriverConfigurazioneException("Nome servizio non trovato"+suffixError);
  498.         }
  499.         if(idServizio.getVersione()==null){
  500.             throw new DriverConfigurazioneException("Versione servizio non trovata"+suffixError);
  501.         }
  502.     }
  503.     
  504. }
Created with JaCoCo 0.8.8.202204050719