WSDLValidator.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.  */




  24. package org.openspcoop2.core.registry.wsdl;

  26. import java.io.ByteArrayOutputStream;
  27. import java.util.ArrayList;
  28. import java.util.List;

  30. import javax.xml.namespace.QName;
  31. import javax.xml.soap.SOAPBody;
  32. import javax.xml.soap.SOAPElement;
  33. import javax.xml.soap.SOAPEnvelope;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.core.registry.Message;
  37. import org.openspcoop2.core.registry.MessagePart;
  38. import org.openspcoop2.core.registry.Operation;
  39. import org.openspcoop2.core.registry.PortType;
  40. import org.openspcoop2.core.registry.constants.BindingStyle;
  41. import org.openspcoop2.core.registry.constants.BindingUse;
  42. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  43. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  44. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  45. import org.openspcoop2.message.MessageUtils;
  46. import org.openspcoop2.message.OpenSPCoop2Message;
  47. import org.openspcoop2.message.constants.MessageType;
  48. import org.openspcoop2.message.soap.SoapUtils;
  49. import org.openspcoop2.utils.UtilsException;
  50. import org.openspcoop2.utils.wsdl.WSDLException;
  51. import org.openspcoop2.utils.xml.AbstractValidatoreXSD;
  52. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  53. import org.openspcoop2.utils.xml.ValidatoreXSD;
  54. import org.slf4j.Logger;
  55. import org.w3c.dom.Attr;
  56. import org.w3c.dom.Comment;
  57. import org.w3c.dom.Document;
  58. import org.w3c.dom.Element;
  59. import org.w3c.dom.NamedNodeMap;
  60. import org.w3c.dom.Node;
  61. import org.w3c.dom.Text;


  64. /**
  65.  * Classe utilizzata per validare i messaggi applicativi.
  66.  *
  67.  * @author Poli Andrea (apoli@link.it)
  68.  * @author Lezza Aldo (lezza@openspcoop.org)
  69.  * @author Lorenzo Nardi (nardi@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  */

  74. public class WSDLValidator {

  76.     public static final String XMLSCHEMA_INSTANCE_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance";
  77.     public static final String XMLSCHEMA_INSTANCE_LOCAL_NAME_TYPE = "type";
  78.     private static final String PREFIX_RPC_AGGIUNTO = "op2RPC";
  79.     
  80.     /** OpenSPCoop2Message */
  81.     private OpenSPCoop2Message openspcoop2Message;
  82.     /** SOAPVersion */
  83.     private MessageType messageType;
  84.     /** Element */
  85.     private Element element;
  86.     /** WSDL Associato al servizio */
  87.     private AccordoServizioWrapper accordoServizioWrapper = null;
  88.     /** Logger */
  89.     private Logger logger = null;
  90.     /** XMLUtils */
  91.     private AbstractXMLUtils xmlUtils = null;
  92.     
  93.     /** Nodo xsiType Aggiunto */
  94.     private boolean gestioneXsiTypeRpcLiteral;
  95.     private SOAPElement rpcChildElement;
  96.     private QName rpcChildElementNamespaceAggiunto;
  97.     private QName rpcChildElementXSITypeAggiunto;
  98.     
  99.     /** Nodo rpc root element */
  100.     private boolean rpcAcceptRootElementUnqualified;
  101.     
  102.     /** XSI Type */
  103.     private boolean validationXsdAddNamespaceXSITypeIfNotExists;
  104.     private boolean validationRpcAddNamespaceXSITypeIfNotExists;
  105.     private boolean validationDocumentAddNamespaceXSITypeIfNotExists;

  107.     /** Prefix error */
  108.     private boolean addPrefixError = true;
  109.     public boolean isAddPrefixError() {
  110.         return this.addPrefixError;
  111.     }
  112.     public void setAddPrefixError(boolean addPrefixError) {
  113.         this.addPrefixError = addPrefixError;
  114.     }
  115.     
  116.     /* ------ Costruttore -------------- */
  117.     private static Element getEngineEnvelopeCatchException(OpenSPCoop2Message msg, boolean bufferMessageReadOnly, String idTransazione) throws WSDLException {
  118.         try {
  119.             boolean checkSoapBodyEmpty = true;
  120.             return MessageUtils.getContentElement(msg, checkSoapBodyEmpty, bufferMessageReadOnly, idTransazione);
  121.         }catch(Exception e){
  122.             throw new WSDLException(e.getMessage(),e);
  123.         }
  124.     }
  125.     public WSDLValidator(OpenSPCoop2Message msg,AbstractXMLUtils xmlUtils,AccordoServizioWrapper accordoServizioWrapper,Logger log,
  126.             WSDLValidatorConfig config, boolean addPrefixError,
  127.             boolean bufferMessageReadOnly, String idTransazione)throws WSDLException{
  128.         this(msg.getMessageType(), getEngineEnvelopeCatchException(msg,bufferMessageReadOnly,idTransazione), xmlUtils, accordoServizioWrapper, log, 
  129.                 config, addPrefixError);
  130.         this.openspcoop2Message = msg;
  131.     }
  132.     // Il costruttore sottostante non puo' sfruttare la funzionalita' addNamespaceXSITypeIfNotExists
  133.     // per questo e' stato reso privato, poiche' tale funzionalita' richiede openspcoop2Message
  134.     private WSDLValidator(MessageType messageType, Element element,AbstractXMLUtils xmlUtils,AccordoServizioWrapper accordoServizioWrapper,Logger log,
  135.             WSDLValidatorConfig config, boolean addPrefixError)throws WSDLException{
  136.         
  137.         this.messageType = messageType;
  138.         
  139.         if(element==null){
  140.             throw new WSDLException("Contenuto da validatore non fornito");
  141.         }
  142.         this.element = element;
  143.         if(MessageType.SOAP_11.equals(this.messageType) || MessageType.SOAP_12.equals(this.messageType)){
  144.             SOAPEnvelope envelope = (SOAPEnvelope) element;
  145.             SOAPBody body = null;
  146.             try{
  147.                 body = envelope.getBody();
  148.             }catch(Exception e){
  149.                 if(this.logger!=null) {
  150.                     this.logger.error("SOAPEnvelope.getBody failed: "+e.getMessage(),e);
  151.                 }
  152.                 throw new WSDLException("SOAPEnvelope senza body");
  153.             }
  154.             
  155.             if(body==null || (body.hasChildNodes()==false)){
  156.                 throw new WSDLException("SOAPBody non esistente");
  157.             }
  158.         }
  159.         
  160.         this.logger = log;
  161.         this.xmlUtils = xmlUtils;
  162.         this.accordoServizioWrapper = accordoServizioWrapper;
  163.         
  164.         this.gestioneXsiTypeRpcLiteral = config.isGestioneXsiTypeRpcLiteral();
  165.         
  166.         this.rpcAcceptRootElementUnqualified = config.isRpcAcceptRootElementUnqualified();
  167.         
  168.         this.validationXsdAddNamespaceXSITypeIfNotExists = config.isValidationXsdAddNamespaceXSITypeIfNotExists();
  169.         this.validationRpcAddNamespaceXSITypeIfNotExists = config.isValidationRpcAddNamespaceXSITypeIfNotExists();
  170.         this.validationDocumentAddNamespaceXSITypeIfNotExists = config.isValidationDocumentAddNamespaceXSITypeIfNotExists();
  171.         
  172.         this.addPrefixError = addPrefixError;
  173.     }
  174.     
  175.     
  176.     
  177.     
  178.     
  179.     
  180.     
  181.     /* -------------- FINALIZE --------------------- */
  182.     public void wsdlConformanceCheck_restoreOriginalDocument(){
  183.         if(this.gestioneXsiTypeRpcLiteral && this.rpcChildElement!=null){
  184.             try{
  185.                 if(this.rpcChildElementXSITypeAggiunto!=null){
  186.                     this.rpcChildElement.removeAttribute(this.rpcChildElementXSITypeAggiunto);
  187.                 }
  188.             }catch(Exception e){
  189.                 this.logger.error("Errore durante l'eliminazione dell'attributo ["+this.rpcChildElementXSITypeAggiunto+"] dal rpc element");
  190.             }
  191.             try{
  192.                 if(this.rpcChildElementNamespaceAggiunto!=null){
  193.                     // alcune implementazioni usano l'uno o l'altro per eliminarlo
  194.                     this.rpcChildElement.removeAttribute(this.rpcChildElementNamespaceAggiunto);
  195.                     this.rpcChildElement.removeNamespaceDeclaration(PREFIX_RPC_AGGIUNTO);
  196.                 }
  197.             }catch(Exception e){
  198.                 this.logger.error("Errore durante l'eliminazione dell'attributo ["+this.rpcChildElementNamespaceAggiunto+"] dal rpc element");
  199.             }
  200.         }
  201.     }
  202.     
  203.     
  204.     
  205.     
  206.     
  207.     
  208.     
  209.     /* -------------- VALIDAZIONE XSD SENZA WSDL --------------------- */
  210.     
  211.     /**
  212.      * Validazione xsd
  213.      * 
  214.      * @param isRichiesta Indicazione sul tipo di messaggio applicativo da gestire
  215.      * @throws WSDLException (contiene codice e msg di errore)
  216.      */
  217.     public void validateAgainstXSDSchema(boolean isRichiesta,String operationName) throws WSDLException,WSDLValidatorException{
  218.         this.validateAgainstXSDSchema(isRichiesta, operationName, this.ptWsdlConformanceCheck, this.opWsdlConformanceCheck);
  219.     }
  220.     public void validateAgainstXSDSchema(boolean isRichiesta,String operationName,PortType portType,Operation operation) throws WSDLException,WSDLValidatorException{

  222.         AbstractValidatoreXSD validatoreBodyApplicativo = null;
  223.         try{
  224.             if(this.accordoServizioWrapper.getSchema()!=null){
  225.                 validatoreBodyApplicativo = new ValidatoreXSD(this.accordoServizioWrapper.getSchema());
  226.             }else{
  227.                 throw new Exception("Schema non costruito?");
  228.             }
  229.         }catch(Exception e){
  230.             throw new WSDLException("Riscontrato errore durante la costruzione del validatore XSD per il contenuto applicativo: "+e.getMessage(),e);
  231.         }
  232.         
  233.         
  234.         /** ricerca ulteriore port type e operation in caso di validazione xsd */
  235.         if(portType==null && this.accordoServizioWrapper.getNomePortType()!=null){
  236.             // provo a cercarlo. Magari non e' stato fatto girare prima il metodo wsdlConformanceCheck
  237.             // o magari volutamente non c'e' un wsdl perche' la validazione prevista e' XSD
  238.             // in tal caso non e' un errore se il port type non e' presente.
  239.             portType = this.accordoServizioWrapper.getPortType(this.accordoServizioWrapper.getNomePortType());
  240.             if(portType==null){
  241.                 try{
  242.                     IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  243.                     String uriAccordo = idAccordoFactory.getUriFromIDAccordo(this.accordoServizioWrapper.getIdAccordoServizio());
  244.                     if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  245.                         this.logger.debug("Port-Type ["+this.accordoServizioWrapper.getNomePortType()+"] non esistente nei wsdl registrati all'interno dell'accordo di servizio "+uriAccordo);
  246.                     }else{
  247.                         this.logger.debug("Servizio ["+this.accordoServizioWrapper.getNomePortType()+"] non esistente nell'accordo di servizio "+uriAccordo);
  248.                     }
  249.                 }catch(Exception e){
  250.                     this.logger.error("Errore durante l'emissione del log che indica la non esistenza del porttype/servizio ["+this.accordoServizioWrapper.getNomePortType()+
  251.                             "] nei wsdl registrati all'interno dell'accordo di servizio: "+e.getMessage(),e);
  252.                 }
  253.             }
  254.         }
  255.         if(operation==null && operationName!=null && portType!=null){
  256.             // provo a cercare l'operation. Magari non e' stato fatto girare prima il metodo wsdlConformanceCheck
  257.             // o magari volutamente non c'e' un wsdl perche' la validazione prevista e' XSD
  258.             // in tal caso non e' un errore se l'operation non e' presente. 
  259.             for(int i=0; i<portType.sizeAzioneList();i++){
  260.                 if(operationName.equals(portType.getAzione(i).getNome())){
  261.                     operation = portType.getAzione(i);
  262.                     break;
  263.                 }
  264.             }
  265.         }
  266.         
  267.         
  268.         StringBuilder errorMsgValidazioneXSD = new StringBuilder();
  269.         
  270.         
  271.         /** Validazione XSD senza considerare gli usi e gli stili (rpc/document e literal/encoded) */
  272.         if(portType==null || operation==null){
  273.             this.logger.debug("Validazione XSD senza considerare il WSDLAccordoServizio e quindi senza considerare style (document/rpc) e gli use (literal/encoded)");
  274.             
  275.             List<Node> nodeList = new ArrayList<Node>();
  276.             if(MessageType.SOAP_11.equals(this.messageType) || MessageType.SOAP_12.equals(this.messageType)){
  277.                 SOAPEnvelope envelope = (SOAPEnvelope) this.element;
  278.                 SOAPBody body = null;
  279.                 try{
  280.                     body = envelope.getBody();
  281.                 }catch(Exception e){
  282.                     // eccezione che non dovrebbe accadere. Lo stesso controllo viene fatto nel costruttore
  283.                     throw new RuntimeException(e.getMessage(),e);
  284.                 }
  285.                 org.w3c.dom.NodeList nl = body.getChildNodes();
  286.                 for(int i=0; i<nl.getLength(); i++){
  287.                     if ( (nl.item(i) instanceof Text) || (nl.item(i) instanceof Comment) ){
  288.                         continue;
  289.                     }
  290.                     nodeList.add(nl.item(i));
  291.                 }
  292.             }
  293.             else{
  294.                 nodeList.add(this.element);
  295.             }
  296.             
  297.             for(int i=0; i<nodeList.size(); i++){
  298.                 String nomeElemento = null;
  299.                 String namespaceElemento = null;
  300.                 Node n = null;
  301.                 try{
  302.                     n = nodeList.get(i);
  303.                     nomeElemento = n.getLocalName();
  304.                     namespaceElemento = n.getNamespaceURI();
  305.                     
  306.                     // Bug Fix: OPPT-784: Validazione fallisce in presenza di xsi:type e normalizzazione da axiom
  307.                     if(this.openspcoop2Message!=null && this.validationXsdAddNamespaceXSITypeIfNotExists) {
  308.                         this.openspcoop2Message.addNamespaceXSITypeIfNotExists(n, this.element);
  309.                     }
  310.                     
  311.                     validatoreBodyApplicativo.valida(n,true);
  312.                 }catch(Exception e){
  313.                     if(errorMsgValidazioneXSD.length()==0){
  314.                         if(this.addPrefixError) {
  315.                             if(isRichiesta) {
  316.                                 errorMsgValidazioneXSD.append("Request");
  317.                             }
  318.                             else {
  319.                                 errorMsgValidazioneXSD.append("Response");
  320.                             }
  321.                             errorMsgValidazioneXSD.append("content not conform to XSD specification\n");
  322.                         }
  323.                     }else{
  324.                         errorMsgValidazioneXSD.append("\n");
  325.                     }
  326.                     if(namespaceElemento!=null){
  327.                         nomeElemento = "{"+namespaceElemento+"}"+nomeElemento;
  328.                     }
  329.                     errorMsgValidazioneXSD.append("(element "+nomeElemento+") "+e.getMessage());
  330.                     String elementNonValidato = null;
  331.                     try{
  332.                         if(n!=null) {
  333.                             elementNonValidato = this.xmlUtils.toString(n);
  334.                         }
  335.                     }catch(Exception eString){
  336.                         this.logger.error("Errore durante la conversione del Node in String: "+eString.getMessage(),eString);
  337.                     }
  338.                     this.logger.error("Validazione fallita (elemento "+nomeElemento+") ["+elementNonValidato+"]: "+e.getMessage(),e);
  339.                 }
  340.             }
  341.         }
  342.         
  343.         /** Validazione XSD che considerare gli usi e gli stili (rpc/document e literal/encoded) */
  344.         else{
  345.             this.logger.debug("Validazione XSD che considera il WSDLAccordoServizio (ho localizzato prima il port-type:"+portType.getNome()+" e l'operation:"+operation.getNome()+")");
  346.             BindingStyle style = CostantiRegistroServizi.WSDL_STYLE_DOCUMENT;
  347.             BindingUse use = CostantiRegistroServizi.WSDL_USE_LITERAL;
  348.             String azione = operationName;
  349.             
  350.             try{
  351.     
  352.                 if(portType.getStyle()!=null && ("".equals(portType.getStyle().getValue())==false) && 
  353.                         CostantiRegistroServizi.WSDL_STYLE_RPC.equals(portType.getStyle()))
  354.                     style = CostantiRegistroServizi.WSDL_STYLE_RPC;
  355.                 
  356.                 if(operation.getStyle()!=null && ("".equals(operation.getStyle().getValue())==false)){
  357.                     if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(operation.getStyle()))
  358.                         style = CostantiRegistroServizi.WSDL_STYLE_RPC;
  359.                     else if(CostantiRegistroServizi.WSDL_STYLE_DOCUMENT.equals(operation.getStyle()))
  360.                         style = CostantiRegistroServizi.WSDL_STYLE_DOCUMENT;
  361.                 }
  362.                 
  363.             }catch(Exception e){
  364.                 if(errorMsgValidazioneXSD.length()>0){
  365.                     errorMsgValidazioneXSD.append("\n");
  366.                 }
  367.                 errorMsgValidazioneXSD.append("Error in recognizing wsdl style rpc/document '"+e.getMessage()+"'");
  368.                 this.logger.error("Validazione fallita durante il riconoscimento del wsdl style rpc/document: "+e.getMessage(),e);
  369.             }
  370.                 
  371.             try{
  372.                 if(isRichiesta){
  373.                     if(operation.getMessageInput()!=null && operation.getMessageInput().getUse()!=null &&
  374.                             ("".equals(operation.getMessageInput().getUse().getValue())==false) &&
  375.                             CostantiRegistroServizi.WSDL_USE_ENCODED.equals(operation.getMessageInput().getUse()))
  376.                         use = CostantiRegistroServizi.WSDL_USE_ENCODED; 
  377.                 }else{
  378.                     if(operation.getMessageOutput()!=null && operation.getMessageOutput().getUse()!=null &&
  379.                             ("".equals(operation.getMessageOutput().getUse().getValue())==false) &&
  380.                             CostantiRegistroServizi.WSDL_USE_ENCODED.equals(operation.getMessageOutput().getUse()))
  381.                         use = CostantiRegistroServizi.WSDL_USE_ENCODED; 
  382.                 }

  384.             }catch(Exception e){
  385.                 if(errorMsgValidazioneXSD.length()>0){
  386.                     errorMsgValidazioneXSD.append("\n");
  387.                 }
  388.                 errorMsgValidazioneXSD.append("Error in recognizing wsdl use literal/encoded '"+e.getMessage()+"'");
  389.                 this.logger.error("Validazione fallita durante il riconoscimento del wsdl style literal/encoded: "+e.getMessage(),e);
  390.             }
  391.             
  392.             if(errorMsgValidazioneXSD.length()==0){
  393.                 this.logger.debug("Validazione XSD con style["+style+"] e use["+use+"]...");
  394.                 
  395.                 List<Node> nodeList = new ArrayList<Node>();
  396.                 if(MessageType.SOAP_11.equals(this.messageType) || MessageType.SOAP_12.equals(this.messageType)){
  397.                     SOAPEnvelope envelope = (SOAPEnvelope) this.element;
  398.                     SOAPBody body = null;
  399.                     try{
  400.                         body = envelope.getBody();
  401.                     }catch(Exception e){
  402.                         // eccezione che non dovrebbe accadere. Lo stesso controllo viene fatto nel costruttore
  403.                         throw new RuntimeException(e.getMessage(),e);
  404.                     }
  405.                     org.w3c.dom.NodeList nl = body.getChildNodes();
  406.                     for(int i=0; i<nl.getLength(); i++){
  407.                         if ( (nl.item(i) instanceof Text) || (nl.item(i) instanceof Comment) ){
  408.                             continue;
  409.                         }
  410.                         nodeList.add(nl.item(i));
  411.                     }
  412.                 }
  413.                 else{
  414.                     nodeList.add(this.element);
  415.                 }
  416.                 
  417.                 if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style)){
  418.                     int children=0;
  419.                     for(int i=0; i<nodeList.size(); i++){
  420.                         children++;
  421.                     }
  422.                     
  423.                     if(children>1){
  424.                         errorMsgValidazioneXSD.append("Operation '"+azione+"' (style RPC) bring more than one root element"); 
  425.                     }
  426.                 }

  428.                 if(errorMsgValidazioneXSD.length()==0){
  429.                     for(int i=0; i<nodeList.size(); i++){
  430.                         String nomeElemento = null;
  431.                         String namespaceElemento = null;
  432.                         Node n = null;
  433.                         Node nodo = null;
  434.                         Node nChild = null;
  435.                         try{
  436.                             n = nodeList.get(i);
  437.                             nomeElemento = n.getLocalName();
  438.                             namespaceElemento = n.getNamespaceURI();
  439.                             if(CostantiRegistroServizi.WSDL_USE_ENCODED.equals(use)){
  440.                                 this.logger.debug("Validazione XSD con style["+style+"] e use["+use+"], richiede la pulizia dei xsi:types prima della validazione...");
  441.                                 nodo = this.cleanXSITypes(n);
  442.                             }else{
  443.                                 nodo = n;
  444.                             }
  445.                                     
  446.                             if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style)){
  447.                                 this.logger.debug("Validazione XSD con style["+style+"] e use["+use+"] RPC Validation...");
  448.                                 String nomeAtteso = azione;
  449.                                 if(isRichiesta==false)
  450.                                     nomeAtteso = azione+"Response";
  451.                                 if(nomeAtteso.equals(nomeElemento)==false){
  452.                                     throw new Exception("Root element ["+nomeElemento+"] non equivale all'operation name "+nomeAtteso +" (RPC Style)");
  453.                                 }
  454.                                 // Valido figli
  455.                                 org.w3c.dom.NodeList nlChilds = nodo.getChildNodes();
  456.                                 this.logger.debug("Valido figli size: "+nlChilds.getLength());
  457.                                 for(int j=0; j<nlChilds.getLength(); j++){
  458.                                     //this.logger.debug("Tipo["+j+"]: "+nlChilds.item(j).getClass().getName());
  459.                                     //if (nlChilds.item(j) instanceof Text && ((Text) nlChilds.item(j)).getData().trim().length() == 0) { continue; }
  460.                                     if ( (nlChilds.item(j) instanceof Text) || (nlChilds.item(j) instanceof Comment) ){
  461.                                         continue;
  462.                                     }
  463.                                     nChild = nlChilds.item(j);
  464.                                     
  465.                                     // Bug Fix: OPPT-784: Validazione fallisce in presenza di xsi:type e normalizzazione da axiom
  466.                                     if(this.openspcoop2Message!=null && this.validationRpcAddNamespaceXSITypeIfNotExists) {
  467.                                         this.openspcoop2Message.addNamespaceXSITypeIfNotExists(nChild, this.element);
  468.                                     }
  469.                                     
  470.                                     validatoreBodyApplicativo.valida(nChild,true);
  471.                                 }
  472.                             }else{
  473.                                 this.logger.debug("Validazione XSD con style["+style+"] e use["+use+"] Document Validation...");
  474.                                 
  475.                                 // Bug Fix: OPPT-784: Validazione fallisce in presenza di xsi:type e normalizzazione da axiom
  476.                                 if(this.openspcoop2Message!=null && this.validationDocumentAddNamespaceXSITypeIfNotExists) {
  477.                                     this.openspcoop2Message.addNamespaceXSITypeIfNotExists(nodo, this.element);
  478.                                 }
  479.                                 
  480.                                 validatoreBodyApplicativo.valida(nodo,true);
  481.                             }
  482.                             
  483.                         }catch(Exception e){
  484.                             if(errorMsgValidazioneXSD.length()==0){
  485.                                 if(this.addPrefixError) {
  486.                                     if(isRichiesta) {
  487.                                         errorMsgValidazioneXSD.append("Request");
  488.                                     }
  489.                                     else {
  490.                                         errorMsgValidazioneXSD.append("Response");
  491.                                     }
  492.                                     errorMsgValidazioneXSD.append("content not conform to XSD specification\n");
  493.                                 }
  494.                             }else{
  495.                                 errorMsgValidazioneXSD.append("\n");
  496.                             }
  497.                             if(namespaceElemento!=null){
  498.                                 nomeElemento = "{"+namespaceElemento+"}"+nomeElemento;
  499.                             }
  500.                             errorMsgValidazioneXSD.append("(element "+nomeElemento+") "+e.getMessage());
  501.                             
  502.                             String elementNonValidato = null;
  503.                             try{
  504.                                 if(n!=null) {
  505.                                     elementNonValidato = this.xmlUtils.toString(n);
  506.                                 }
  507.                             }catch(Exception eString){
  508.                                 this.logger.error("Errore durante la conversione del Node in String: "+eString.getMessage(),eString);
  509.                             }
  510.                             
  511.                             String elementNonValidato_cleanXSIType = null;
  512.                             try{
  513.                                 if(nodo!=null) {
  514.                                     elementNonValidato_cleanXSIType = this.xmlUtils.toString(nodo);
  515.                                 }
  516.                             }catch(Exception eString){
  517.                                 this.logger.error("Errore durante la conversione del Node (clean xsiType) in String: "+eString.getMessage(),eString);
  518.                             }
  519.                             
  520.                             String elementNonValidato_child = null;
  521.                             try{
  522.                                 if(nChild!=null)
  523.                                     elementNonValidato_child = this.xmlUtils.toString(nChild);
  524.                             }catch(Exception eString){
  525.                                 this.logger.error("Errore durante la conversione del Node (clean xsiType) in String: "+eString.getMessage(),eString);
  526.                             }
  527.                             
  528.                             this.logger.error("Validazione fallita (elemento "+nomeElemento+") originale["+
  529.                                     elementNonValidato+"] cleanXsiType["+
  530.                                     elementNonValidato_cleanXSIType+"] nChild["+
  531.                                     elementNonValidato_child+"]: "+e.getMessage(),e);
  532.                         }
  533.                     }
  534.                 }
  535.             }
  536.         }
  537.         if(errorMsgValidazioneXSD.length()>0){
  538.             throw new WSDLValidatorException(errorMsgValidazioneXSD.toString());
  539.         }
  540.     }

  542.     
  543.     
  544.     
  545.     
  546.     
  547.     
  548.     
  549.     
  550.     
  551.     
  552.     /* -------------- VALIDAZIONE XSD CON WSDL --------------------- */
  553.     
  554.     /**
  555.      * Validazione WSDL
  556.      * 
  557.      * @param isRichiesta Indicazione sul tipo di messaggio applicativo da gestire
  558.      * 
  559.      */
  560.     private PortType ptWsdlConformanceCheck = null;
  561.     private Operation opWsdlConformanceCheck = null;
  562.     public PortType getPtWsdlConformanceCheck() {
  563.         return this.ptWsdlConformanceCheck;
  564.     }
  565.     public Operation getOpWsdlConformanceCheck() {
  566.         return this.opWsdlConformanceCheck;
  567.     }
  568. //  public void wsdlConformanceCheck(boolean isRichiesta,String soapAction,String operationName) throws WSDLValidatorException {
  569. //      this.wsdlConformanceCheck(isRichiesta, soapAction, operationName, true, false);
  570. //  }
  571.     public void wsdlConformanceCheck(boolean isRichiesta,String soapAction,String operationName,boolean throwSOAPActionException,boolean logErrorAsDebug) throws WSDLValidatorException {
  572.                 
  573.         String portType = this.accordoServizioWrapper.getNomePortType();
  574.         
  575.         if(portType!=null){
  576.             
  577.             // l'accordo di servizio parte specifica e' stato collegato ad un port type nella parte comune.
  578.             // In tal caso uso la validazione ottimale rispetto al port type ed all'operation
  579.             
  580.             // l'azione busta deve essere obbligatoriamente presente.
  581.             if(operationName==null){
  582.                 throw new WSDLValidatorException("Operation name undefined");
  583.             }
  584.             
  585.             this.logger.info("WSDL, effettuo validazione wsdlConformanceCheck ottimale sia con port type che operation ...");
  586.             this._engineWsdlConformanceCheck(isRichiesta, soapAction, portType, operationName, throwSOAPActionException, logErrorAsDebug);
  587.             
  588.             // se la validazione ha avuto successo salvo il pt e l'operation
  589.             this.ptWsdlConformanceCheck = this.accordoServizioWrapper.getPortType(portType);
  590.             for(int i=0; i<this.ptWsdlConformanceCheck.sizeAzioneList(); i++){
  591.                 Operation operationAS = this.ptWsdlConformanceCheck.getAzione(i);
  592.                 if (operationAS.getNome().equals(operationName)) {
  593.                     this.opWsdlConformanceCheck = operationAS;
  594.                     break;
  595.                 }
  596.             }
  597.         }
  598.         else{
  599.             
  600.             // l'accordo di servizio parte specifica non e' stato collegato ad un port type nella parte comune. 
  601.             // effettuo una validazione meno stringente.
  602.                 
  603.             if(operationName!=null){
  604.                 
  605.                 // *** cerco l'operation all'interno del wsdl. Se esiste una o piu' operation con tale nome, proviamo a validare il messaggio. ***
  606.                 this.logger.info("WSDL, effettuo validazione wsdlConformanceCheck cercando una qualche operation con nome ["+operationName+"]...");
  607.                 StringBuilder bfEccezione = new StringBuilder();
  608.                 boolean operationFound = _engineWsdlConformanceCheckAll(isRichiesta, soapAction, operationName, bfEccezione, throwSOAPActionException, logErrorAsDebug);
  609.                 if(operationFound){
  610.                     if(bfEccezione.length()>0){
  611.                         throw new WSDLValidatorException(bfEccezione.toString());
  612.                     }
  613.                     else{
  614.                         return;
  615.                     }
  616.                 }else{
  617.                     try{
  618.                         IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  619.                         String uriAccordo = idAccordoFactory.getUriFromIDAccordo(this.accordoServizioWrapper.getIdAccordoServizio());
  620.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  621.                             throw new WSDLValidatorException("Operation '"+operationName+"' undefined in the WSDL specification '"+uriAccordo+"'");
  622.                         }else{
  623.                             throw new WSDLValidatorException("Operation '"+operationName+"' undefined in the API specification '"+uriAccordo+"'");
  624.                         }
  625.                     }catch(DriverRegistroServiziException de){
  626.                         String msgErrore = "Errore durante la registrazione del messaggio di errore Operation ["+operationName+"] non trovata in alcun port-type esistente nei wsdl registrati all'interno dell'accordo di servizio";
  627.                         if(logErrorAsDebug){
  628.                             this.logger.debug(msgErrore);
  629.                         }else{
  630.                             this.logger.error(msgErrore,de);
  631.                         }
  632.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  633.                             throw new WSDLValidatorException("Operation '"+operationName+"' undefined in the WSDL specification");
  634.                         }else{
  635.                             throw new WSDLValidatorException("Operation '"+operationName+"' undefined in the API specification");
  636.                         }
  637.                     }
  638.                 }
  639.             }
  640.             else{
  641.             
  642.                 // *** 
  643.                 //     non avendo trovato una azione che matchava con il nome dell'operation name, 
  644.                 //     valido rispetto a tutti i messaggi possibili, rispettando pero' il ruolo tra richiesta e risposta 
  645.                 //  ***     
  646.                 StringBuilder bfEccezione = new StringBuilder();
  647.                 this.logger.info("WSDL, effettuo validazione wsdlConformanceCheck utilizzando una qualunque operation ...");
  648.                 _engineWsdlConformanceCheckAll(isRichiesta, soapAction, null, bfEccezione, throwSOAPActionException, logErrorAsDebug);
  649.                 if(bfEccezione.length()>0){
  650.                     throw new WSDLValidatorException(bfEccezione.toString());
  651.                 }
  652.                 else{
  653.                     return;
  654.                 }
  655.                 
  656.             }
  657.             
  658.         }
  659.         
  660.     }
  661.     
  662.     private boolean _engineWsdlConformanceCheckAll(boolean isRichiesta,String soapAction,String operationName, StringBuilder bfEccezione,boolean throwSOAPActionException,boolean logErrorAsDebug) throws WSDLValidatorException{
  663.         
  664.         try{
  665.         
  666.             IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  667.             String uriAccordo = idAccordoFactory.getUriFromIDAccordo(this.accordoServizioWrapper.getIdAccordoServizio());
  668.             
  669.             PortType [] pts = this.accordoServizioWrapper.getPortTypeList();
  670.             if(pts==null || pts.length<=0){
  671.                 if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  672.                     throw new WSDLValidatorException("PortTypes undefined in the WSDL specification '"+uriAccordo+"'");
  673.                 }else{
  674.                     throw new WSDLValidatorException("PortTypes undefined in the API specification '"+uriAccordo+"'");
  675.                 }
  676.             }
  677.             boolean operationFound = false;
  678.             for (int i = 0; i < pts.length; i++) {
  679.                 PortType pt = pts[i];
  680.                 List<Operation> ops = pt.getAzioneList();
  681.                 if(ops==null || ops.size()<=0){
  682.                     if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  683.                         throw new WSDLValidatorException("Operations undefined in PortType '"+pt.getNome()+"' of the WSDL specification '"+uriAccordo+"'");
  684.                     }else{
  685.                         throw new WSDLValidatorException("Operations undefined in Service '"+pt.getNome()+"' of the API specification '"+uriAccordo+"'");
  686.                     }
  687.                 }
  688.                 boolean validazioneCompletataConSuccesso = false;
  689.                 for (Operation operation : ops) {
  690.                     
  691.                     boolean verify = false;
  692.                     if(operationName==null){
  693.                         verify = true;
  694.                     }
  695.                     else{
  696.                         verify = (operation.getNome().equals(operationName));
  697.                         if(verify){
  698.                             operationFound = true;
  699.                         }
  700.                     }
  701.                     
  702.                     if(verify){
  703.                         try{
  704.                             this.logger.info("WSDL, effettuo validazione wsdlConformanceCheck per operation ["+operation.getNome()+"] del port type ["+pt.getNome()+"]...");
  705.                             this._engineWsdlConformanceCheck(isRichiesta, soapAction, pt.getNome(), operation.getNome(), throwSOAPActionException, logErrorAsDebug);
  706.                             
  707.                             // se la validazione ha avuto successo salvo il pt e l'operation
  708.                             this.ptWsdlConformanceCheck = pt;
  709.                             this.opWsdlConformanceCheck = operation;
  710.                             
  711.                             validazioneCompletataConSuccesso = true;
  712.                             break;
  713.                             
  714.                         }catch(WSDLValidatorException exception){
  715. //                          if(bfEccezione.length()>0){
  716.                             bfEccezione.append("\n");
  717.                             //}
  718.                             bfEccezione.append("[Tentativo validazione come PortType:").
  719.                                 append(pt.getNome()).
  720.                                 append(" Operation:").
  721.                                 append(operation.getNome()).
  722.                                 append(" fallito]: ").
  723.                                 append(exception.getMessage());
  724.                         }
  725.                     }
  726.                 }
  727.                 
  728.                 if(validazioneCompletataConSuccesso){
  729.                     break;
  730.                 }
  731.             }
  732.             
  733.             return operationFound;
  734.             
  735.         }catch(WSDLValidatorException e){
  736.             throw e;
  737.         }catch(Exception e){
  738.             // Si entra in questo catch solo in caso di bug
  739.             String msgErrore = "Validazione WSDL ("+isRichiesta+") fallita: "+e.getMessage();
  740.             if(logErrorAsDebug){
  741.                 this.logger.debug(msgErrore);
  742.             }else{
  743.                 this.logger.error(msgErrore,e);
  744.             }
  745.             throw new WSDLValidatorException("WSDL Validation 'all-"+(isRichiesta?"request":"response")+"' failed: "+e.getMessage(),e);
  746.         }
  747.     }
  748.     
  749.     private void _engineWsdlConformanceCheck(boolean isRichiesta,String soapAction,String portType,String operation,boolean throwSOAPActionException,boolean logErrorAsDebug) throws WSDLValidatorException {
  750.         
  751.         String errorMsgValidazioneXSD = null;
  752.         try{
  753.             
  754.             SOAPEnvelope envelope = null;
  755.             SOAPBody body = null;
  756.             if(MessageType.SOAP_11.equals(this.messageType) || MessageType.SOAP_12.equals(this.messageType)){
  757.                 envelope = (SOAPEnvelope) this.element;
  758.                 try{
  759.                     body = envelope.getBody();
  760.                 }catch(Exception e){
  761.                     // eccezione che non dovrebbe accadere. Lo stesso controllo viene fatto nel costruttore
  762.                     throw new RuntimeException(e.getMessage(),e);
  763.                 }
  764.             }
  765.             else{
  766.                 throw new Exception("Tipo di validazione non supportata con Service Binding REST e tipologia messaggio: "+this.messageType.getMessageVersionAsString());
  767.             }
  768.             
  769.     
  770.             // cerco port-type
  771.             BindingStyle style = CostantiRegistroServizi.WSDL_STYLE_DOCUMENT;
  772.             BindingUse use = CostantiRegistroServizi.WSDL_USE_LITERAL;
  773.             String namespaceRPC = null;
  774.             Node rpcElement = null;
  775.             IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  776.             String uriAccordo = idAccordoFactory.getUriFromIDAccordo(this.accordoServizioWrapper.getIdAccordoServizio());
  777.             PortType portTypeAS = this.accordoServizioWrapper.getPortType(portType);
  778.             if(portTypeAS==null){
  779.                 if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  780.                     throw new WSDLValidatorException("PortType ["+portType+"] undefined in the WSDL specification '"+uriAccordo+"'");
  781.                 }else{
  782.                     throw new WSDLValidatorException("Service ["+portType+"] undefined in the API specification '"+uriAccordo+"'");
  783.                 }
  784.             }
  785.             if(portTypeAS.getStyle()!=null && ("".equals(portTypeAS.getStyle().getValue())==false) && 
  786.                     CostantiRegistroServizi.WSDL_STYLE_RPC.equals(portTypeAS.getStyle()))
  787.                 style = CostantiRegistroServizi.WSDL_STYLE_RPC;
  788.             
  789.             //si itera sulle operazioni del portType perche' potrebbe esserci
  790.             //overload di operazioni
  791.             if(portTypeAS.sizeAzioneList()<=0)
  792.                 throw new Exception("operations per il port type ["+portType+"] non presenti");
  793.             boolean matchingNameOperation = false, matchingArgomentsOperation = false;
  794.             String soapActionWSDL = null;
  795.             StringBuilder eccezioni = new StringBuilder();
  796.             StringBuilder eccezioneActionMatch = new StringBuilder();
  797.             for(int i=0; i<portTypeAS.sizeAzioneList(); i++){
  798.                 Operation operationAS = portTypeAS.getAzione(i);
  799.                 if (operationAS.getNome().equals(operation)) {
  800.                     matchingNameOperation = true;
  801.                     // Prendo la definizione del messaggio di input se e' una richiesta, di output se e' una risposta
  802.                     Message argumentsOperation = isRichiesta ? operationAS.getMessageInput() : operationAS.getMessageOutput();
  803.                     
  804.                     if(operationAS.getStyle()!=null && ("".equals(operationAS.getStyle().getValue())==false)){
  805.                         if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(operationAS.getStyle()))
  806.                             style = CostantiRegistroServizi.WSDL_STYLE_RPC;
  807.                         else if(CostantiRegistroServizi.WSDL_STYLE_DOCUMENT.equals(operationAS.getStyle()))
  808.                             style = CostantiRegistroServizi.WSDL_STYLE_DOCUMENT;
  809.                     }
  810.                     
  811.                     if(argumentsOperation!=null && argumentsOperation.getUse()!=null &&
  812.                             ("".equals(argumentsOperation.getUse().getValue())==false) &&
  813.                             CostantiRegistroServizi.WSDL_USE_ENCODED.equals(argumentsOperation.getUse()))
  814.                         use = CostantiRegistroServizi.WSDL_USE_ENCODED; 
  815.                     
  816.                     if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style)){
  817.                         if(argumentsOperation!=null && argumentsOperation.getSoapNamespace()!=null &&
  818.                                 (!"".equals(argumentsOperation.getSoapNamespace()))){
  819.                             namespaceRPC = argumentsOperation.getSoapNamespace();
  820.                         }
  821.                     }
  822.                                         
  823.                     this.logger.debug("WSDL, esamino operation["+operation+"] con style["+style+"] e use["+use+"] (RPCNamespace:"+namespaceRPC+") ...");
  824.                     
  825.                     // il controllo sul nome dell'operation non basta.
  826.                     // Vi puo' essere overriding del metodo per parametri diversi
  827.                     // controllo matching dei parametri 
  828.                     org.w3c.dom.NodeList nodiContenutoApplicativo = null;
  829.                     Node nodoPossiedeContenutoApplicativo = null; // body nel caso document, rpc-element nel caso rpc
  830.                     if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style)){
  831.                         // RPC
  832.                         String nomeAtteso = operation;
  833.                         if(isRichiesta==false)
  834.                             nomeAtteso = operation+"Response";
  835.                         SOAPElement childRPCElement = SoapUtils.getNotEmptyFirstChildSOAPElement(body);
  836.                         if(childRPCElement==null){
  837.                             this.logger.debug("WSDL, esamino operation["+operation+"] con style["+style+"] e use["+use+"]: Root element RCP non trovato rispetto all'operation name "+nomeAtteso +" (RPC Style)");
  838.                             continue;
  839.                         }
  840.                         if(nomeAtteso.equals(childRPCElement.getLocalName())==false){
  841.                             this.logger.debug("WSDL, esamino operation["+operation+"] con style["+style+"] e use["+use+"]: Root element ["+childRPCElement.getLocalName()+"] non equivale all'operation name "+nomeAtteso +" (RPC Style)");
  842.                             continue;
  843.                         }
  844.                         
  845.                         nodiContenutoApplicativo = body.getChildNodes();
  846.                         for(int ii=0;ii<nodiContenutoApplicativo.getLength();ii++){
  847. //                          if (!(nodiContenutoApplicativo.item(ii) instanceof Text && 
  848. //                                  ((Text) nodiContenutoApplicativo.item(ii)).getData().trim().length() == 0)) { 
  849.                             if (! ( (nodiContenutoApplicativo.item(ii) instanceof Text) || (nodiContenutoApplicativo.item(ii) instanceof Comment) )){
  850.                                 nodoPossiedeContenutoApplicativo = nodiContenutoApplicativo.item(ii);
  851.                                 rpcElement = nodoPossiedeContenutoApplicativo;
  852.                                 nodiContenutoApplicativo = nodoPossiedeContenutoApplicativo.getChildNodes();
  853.                                 break;
  854.                             }
  855.                         }
  856.                         
  857.                     }else{
  858.                         // Document
  859.                         nodiContenutoApplicativo = body.getChildNodes();
  860.                         nodoPossiedeContenutoApplicativo = body;
  861.                     }
  862.                     
  863.                     int sizeArgumentsOperation = 0;
  864.                     if(argumentsOperation!=null){
  865.                         sizeArgumentsOperation = argumentsOperation.sizePartList();
  866.                     }
  867.                     int nodiContenutoApplicativoLength = 0;
  868.                     StringBuilder nodiMessaggioErrore = new StringBuilder();
  869.                     for(int ii=0;ii<nodiContenutoApplicativo.getLength();ii++){
  870. //                      if (!(nodiContenutoApplicativo.item(ii) instanceof Text && 
  871. //                              ((Text) nodiContenutoApplicativo.item(ii)).getData().trim().length() == 0)) { 
  872.                         if (! ( (nodiContenutoApplicativo.item(ii) instanceof Text) || (nodiContenutoApplicativo.item(ii) instanceof Comment) )){
  873.                             
  874.                             if(nodiMessaggioErrore.length()>0){
  875.                                 nodiMessaggioErrore.append(", ");
  876.                             }
  877.                             Node n = nodiContenutoApplicativo.item(ii);
  878.                             RootElementBody rootElementBody = new RootElementBody(envelope, nodoPossiedeContenutoApplicativo, 
  879.                                     CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style), n);
  880.                             nodiMessaggioErrore.append(rootElementBody.toString());
  881.                             
  882.                             nodiContenutoApplicativoLength++;
  883.                             continue;
  884.                         }
  885.                     }
  886.                     if(sizeArgumentsOperation!=nodiContenutoApplicativoLength){
  887.                         
  888.                         if(eccezioneActionMatch.length()>0){
  889.                             eccezioneActionMatch.append("\n");
  890.                         }
  891.                         eccezioneActionMatch.append("Found "+nodiContenutoApplicativoLength+" parameter"+(nodiContenutoApplicativoLength>1?"s":"")+": ");
  892.                         eccezioneActionMatch.append(nodiMessaggioErrore.toString());
  893.                         
  894.                         this.logger.debug("WSDL, esamino operation["+operation+"] con style["+style+"] e use["+use+"]: Argomenti attesi["+sizeArgumentsOperation+"], trovati nel body["+nodiContenutoApplicativo.getLength()+"]");
  895.                         continue;
  896.                     }
  897.                                         
  898.                     String tipo  = "output";
  899.                     if(isRichiesta)
  900.                         tipo = "input";
  901.                     
  902.                     if(argumentsOperation!=null && argumentsOperation.sizePartList()>0){
  903.                         
  904.                         // Mi conservo gli elementi presenti nel body
  905.                         List<RootElementBody> elementRootBody = new ArrayList<RootElementBody>();
  906.                         StringBuilder bodyElements = new StringBuilder();
  907.                         int numeroBodyElements = 0;
  908.                         int realIndexBody = 0;
  909.                         for(int indexBody = 0 ; indexBody<nodiContenutoApplicativo.getLength(); indexBody++){
  910. //                          if (nodiContenutoApplicativo.item(indexBody) instanceof Text && 
  911. //                                  ((Text) nodiContenutoApplicativo.item(indexBody)).getData().trim().length() == 0) { 
  912.                             if ( (nodiContenutoApplicativo.item(indexBody) instanceof Text) || (nodiContenutoApplicativo.item(indexBody) instanceof Comment) ){
  913.                                 continue;
  914.                             }
  915.                             
  916.                             Node n = nodiContenutoApplicativo.item(indexBody);
  917.                             
  918.                             RootElementBody rootElementBody = new RootElementBody(envelope, nodoPossiedeContenutoApplicativo, 
  919.                                     CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style), n);
  920.                             elementRootBody.add(rootElementBody);
  921.                             
  922.                             if(realIndexBody>0)
  923.                                 bodyElements.append(",");
  924.                             realIndexBody++;
  925.                             bodyElements.append(rootElementBody.toString());
  926.                         }
  927.                         numeroBodyElements = elementRootBody.size();
  928.                         
  929.                         int soapBodyArguments = nodiContenutoApplicativoLength;
  930.                         //per ogni tipo si itera
  931.                         int wsdlIndex=0;
  932.                         for( ; wsdlIndex<argumentsOperation.sizePartList(); wsdlIndex++){
  933.                             if (wsdlIndex == soapBodyArguments) { 
  934.                                 //più oggetti definiti nel WSDL di quanti ce ne siano nel messaggio
  935.                                 this.logger.debug("WSDL, esamino operation["+operation+"] con style["+style+"] e use["+use+"]: Più oggetti definiti nel WSDL di quanti ce ne siano nel messaggio");
  936.                                 continue;
  937.                             }
  938.                             MessagePart argument = argumentsOperation.getPart(wsdlIndex);
  939.                             String nomeElementAtteso = null;
  940.                             String namespaceElementAtteso = null;
  941.                             String tipoXSIAtteso = null;
  942.                             boolean validazioneTipologiaElement = (argument.getElementName()!=null);
  943.                             String argomentoAtteso = null;
  944.                             if(argument.getElementName()!=null){
  945.                                 nomeElementAtteso = argument.getElementName();
  946.                                 namespaceElementAtteso = argument.getElementNamespace();
  947.                             }
  948.                             else{
  949.                                 nomeElementAtteso = argument.getName(); // definito nel message del wsdl
  950.                                 namespaceElementAtteso = argument.getTypeNamespace();
  951.                                 tipoXSIAtteso = argument.getTypeName();
  952.                             }
  953.                             argomentoAtteso = RootElementBody.toString(nomeElementAtteso, namespaceElementAtteso, tipoXSIAtteso);
  954.                             boolean find = false;
  955.                             for(int indexBody = 0 ; indexBody<elementRootBody.size(); indexBody++){
  956.                                 RootElementBody r = elementRootBody.get(indexBody);
  957.                                 if(validazioneTipologiaElement){
  958.                                     if(nomeElementAtteso.equals(r.getLocalName()) && namespaceElementAtteso.equals(r.getNamespace())){
  959.                                         find = true;
  960.                                         elementRootBody.remove(indexBody);
  961.                                         continue;
  962.                                     }
  963.                                     else if(CostantiRegistroServizi.WSDL_USE_ENCODED.equals(use)){
  964.                                         if(nomeElementAtteso.equals(r.getLocalName()) && namespaceElementAtteso.equals(r.getNamespaceElementoCheContieneXSIType())){
  965.                                             find = true;
  966.                                             elementRootBody.remove(indexBody);
  967.                                             continue;
  968.                                         }
  969.                                     }
  970.                                 }
  971.                                 else{
  972.                                     if(nomeElementAtteso.equals(r.getLocalName()) && 
  973.                                             namespaceElementAtteso.equals(r.getNamespace()) &&
  974.                                             tipoXSIAtteso.equals(r.getXsiType())){
  975.                                         find = true;
  976.                                         elementRootBody.remove(indexBody);
  977.                                         continue;
  978.                                     }
  979.                                 }
  980.                             }
  981.     
  982.                             if (!find) { //tipi non concordi nella sequenza
  983.                                 boolean error = true;
  984.                                 if(CostantiRegistroServizi.WSDL_STYLE_RPC.equals(style) && CostantiRegistroServizi.WSDL_USE_LITERAL.equals(use) &&
  985.                                         tipoXSIAtteso!=null &&
  986.                                         elementRootBody.size()==1 && // elementi nel body sono uno
  987.                                         argumentsOperation.sizePartList()==1 // elementi attesi nel wsdl uno 
  988.                                         ){
  989.                                     
  990.                                     SOAPElement rpcOperation = SoapUtils.getNotEmptyFirstChildSOAPElement(body);
  991.                                     if(rpcOperation!=null){
  992.                                         SOAPElement childRpc = SoapUtils.getNotEmptyFirstChildSOAPElement(rpcOperation);
  993.                                         if(this.gestioneXsiTypeRpcLiteral && 
  994.                                                 childRpc!=null && nomeElementAtteso!=null && nomeElementAtteso.equals(childRpc.getLocalName())){
  995.                                             try{
  996. //                                              System.out.println("PRIMA: "+org.openspcoop2.message.OpenSPCoop2MessageFactory.getMessageFactory().createEmptySOAPMessage(SOAPVersion.SOAP11).
  997. //                                                      getAsString(childRpc, false));
  998.                                                 
  999.                                                 QName namespaceId = new QName("xmlns:"+PREFIX_RPC_AGGIUNTO);
  1000.                                                 childRpc.addAttribute(namespaceId, namespaceElementAtteso);
  1001.                                                 this.rpcChildElementNamespaceAggiunto = namespaceId;
  1002.                                             
  1003.                                                 QName id = new QName(XMLSCHEMA_INSTANCE_NAMESPACE,XMLSCHEMA_INSTANCE_LOCAL_NAME_TYPE,"xsi");
  1004.                                                 String value = PREFIX_RPC_AGGIUNTO+":"+tipoXSIAtteso;
  1005.                                                 childRpc.addAttribute(id, value);
  1006.                                                 this.rpcChildElementXSITypeAggiunto = id;
  1007.                                             
  1008. //                                              System.out.println("DOPO: "+org.openspcoop2.message.OpenSPCoop2MessageFactory.getMessageFactory().createEmptySOAPMessage(SOAPVersion.SOAP11).
  1009. //                                                      getAsString(childRpc, false));
  1010.                                                 error= false;
  1011.                                                 this.rpcChildElement = childRpc;
  1012.                                             }catch(Exception e){
  1013.                                                 this.logger.error("Errore durante la registrazione degli attributi richiesti per la validazione rpc con type: "+e.getMessage(),e);
  1014.                                                 try{
  1015.                                                     if(this.rpcChildElementNamespaceAggiunto!=null){
  1016.                                                         // ripulisco
  1017.                                                         // alcune implementazioni usano l'uno o l'altro per eliminarlo
  1018.                                                         this.rpcChildElement.removeAttribute(this.rpcChildElementNamespaceAggiunto);
  1019.                                                         this.rpcChildElement.removeNamespaceDeclaration(PREFIX_RPC_AGGIUNTO);
  1020.                                                     }
  1021.                                                 }catch(Exception eClose){
  1022.                                                     // ignore
  1023.                                                 }
  1024.                                             }
  1025.                                         }
  1026.                                     }
  1027.                                 }
  1028.                                 if(error){
  1029.                                     eccezioni.append("\nRequired "+tipo+" parameter '"+argomentoAtteso+"' undefined in "+numeroBodyElements+" body root-element("+(numeroBodyElements>1?"s":"")+") founded: "+bodyElements);
  1030.                                     this.logger.debug("WSDL, esamino operation["+operation+"] con style["+style+"] e use["+use+"]: Atteso "+argomentoAtteso+" body "+bodyElements);
  1031.                                     break;
  1032.                                 }
  1033.                             }
  1034.                         }
  1035.                         if (wsdlIndex == soapBodyArguments) {
  1036.                             soapActionWSDL = operationAS.getSoapAction();
  1037.                             matchingArgomentsOperation = true;
  1038.                             continue;
  1039.                         }
  1040.                     }

  1042.                 } //fine if
  1043.             }

  1045.             if (!matchingArgomentsOperation) {
  1046.                 if (matchingNameOperation) {
  1047.                     if(eccezioni.length()>0){
  1048.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1049.                             throw new WSDLValidatorException("Invalid "+(isRichiesta?"request":"response")+" by WSDL specification '"+uriAccordo+"' (port-type:"+portType+", operation:"+operation+", style:"+style+", use:"+use+"): "+eccezioni.toString());
  1050.                         }else{
  1051.                             throw new WSDLValidatorException("Invalid "+(isRichiesta?"request":"response")+" by API specification '"+uriAccordo+"' (service:"+portType+", operation:"+operation+", style:"+style+", use:"+use+"): "+eccezioni.toString());
  1052.                         }
  1053.                     }
  1054.                     else if(eccezioneActionMatch.length()>0){
  1055.                         StringBuilder bfMessage = new StringBuilder();
  1056.                         for(int i=0; i<portTypeAS.sizeAzioneList(); i++){
  1057.                             Operation operationAS = portTypeAS.getAzione(i);
  1058.                             if (operationAS.getNome().equals(operation)) {
  1059.                                 Message argumentsOperation = isRichiesta ? operationAS.getMessageInput() : operationAS.getMessageOutput();
  1060.                                 int length = 0;
  1061.                                 if(argumentsOperation!=null && argumentsOperation.getPartList()!=null){
  1062.                                     length = argumentsOperation.getPartList().size();
  1063.                                 }
  1064.                                 bfMessage.append("\n");
  1065.                                 bfMessage.append("Expected "+length+" parameter"+(length>1?"s":"")+": ");
  1066.                                 if(length>0){
  1067.                                     for (int j = 0; j < length; j++) {
  1068.                                         MessagePart argument = argumentsOperation.getPart(j);
  1069.                                         String nomeElementAtteso = null;
  1070.                                         String namespaceElementAtteso = null;
  1071.                                         String tipoXSIAtteso = null;
  1072.                                         String argomentoAtteso = null;
  1073.                                         if(argument.getElementName()!=null){
  1074.                                             nomeElementAtteso = argument.getElementName();
  1075.                                             namespaceElementAtteso = argument.getElementNamespace();
  1076.                                         }
  1077.                                         else{
  1078.                                             nomeElementAtteso = argument.getName(); // definito nel message del wsdl
  1079.                                             namespaceElementAtteso = argument.getTypeNamespace();
  1080.                                             tipoXSIAtteso = argument.getTypeName();
  1081.                                         }
  1082.                                         argomentoAtteso = RootElementBody.toString(nomeElementAtteso, namespaceElementAtteso, tipoXSIAtteso);
  1083.                                         if(j>0){
  1084.                                             bfMessage.append(", ");
  1085.                                         }
  1086.                                         bfMessage.append(argomentoAtteso);
  1087.                                     }
  1088.                                 }
  1089.                             }
  1090.                         }
  1091.                         bfMessage.append("\n").append(eccezioneActionMatch.toString());

  1093.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1094.                             throw new WSDLValidatorException("Invalid "+(isRichiesta?"request":"response")+" by WSDL specification '"+uriAccordo+"' (port-type:"+portType+", operation:"+operation+", style:"+style+", use:"+use+"): "+bfMessage.toString());
  1095.                         }else{
  1096.                             throw new WSDLValidatorException("Invalid "+(isRichiesta?"request":"response")+" by API specification '"+uriAccordo+"' (service:"+portType+", operation:"+operation+", style:"+style+", use:"+use+"): "+bfMessage.toString());
  1097.                         }

  1099.                     }
  1100.                     else{
  1101.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1102.                             throw new WSDLValidatorException("Invalid "+(isRichiesta?"request":"response")+" by WSDL specification '"+uriAccordo+"' (port-type:"+portType+", operation:"+operation+", style:"+style+", use:"+use+")");
  1103.                         }else{
  1104.                             throw new WSDLValidatorException("Invalid "+(isRichiesta?"request":"response")+" by API specification '"+uriAccordo+"' (service:"+portType+", operation:"+operation+", style:"+style+", use:"+use+")");
  1105.                         }
  1106.                     }
  1107.                 } else {
  1108.                     if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1109.                         throw new WSDLValidatorException("Operation '"+operation+"' undefined in PortType '"+portType+"' of the WSDL specification '"+uriAccordo+"'");
  1110.                     }else{
  1111.                         throw new WSDLValidatorException("Operation '"+operation+"' undefined in Service '"+portType+"' of the API specification '"+uriAccordo+"'");
  1112.                     }
  1113.                 }
  1114.             }
  1115.             
  1116.             if( isRichiesta && soapActionWSDL!=null){
  1117.                 this.logger.debug("CheckSOAPAction");
  1118.                 String soapActionRipulita = null;
  1119.                 if(soapAction!=null){
  1120.                     soapActionRipulita = soapAction.trim();
  1121.                     if(soapActionRipulita.startsWith("\"")){
  1122.                         soapActionRipulita = soapActionRipulita.substring(1);
  1123.                     }
  1124.                     if(soapActionRipulita.endsWith("\"")){
  1125.                         soapActionRipulita = soapActionRipulita.substring(0,(soapActionRipulita.length()-1));
  1126.                     }
  1127.                 }
  1128.                 if(soapActionWSDL.equalsIgnoreCase(soapActionRipulita)==false){
  1129.                     boolean tmpThrowSOAPActionException = throwSOAPActionException;
  1130.                     if(soapActionRipulita==null && MessageType.SOAP_12.equals(this.messageType)){
  1131.                         // The SOAP 1.1 mandatory SOAPAction HTTP header has been removed in SOAP 1.2. In its place is an optional action parameter on the application/soap+xml media type.
  1132.                         // Quindi se nella richiesta non era presente una soapAction, non devo sollevare eccezione
  1133.                         tmpThrowSOAPActionException = false;
  1134.                     }
  1135.                     // Validazione SOAPAction
  1136.                     if(tmpThrowSOAPActionException){
  1137.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1138.                             throw new WSDLValidatorException("Invalid soap action '"+soapActionRipulita+"' by WSDL specification '"+uriAccordo+"' (port-type:"+portType+", operation:"+operation+", soap action:"+soapActionWSDL+")");
  1139.                         }else{
  1140.                             throw new WSDLValidatorException("Invalid soap action '"+soapActionRipulita+"' by API specification '"+uriAccordo+"' (service:"+portType+", operation:"+operation+", soap action:"+soapActionWSDL+")");
  1141.                         }
  1142.                     }
  1143.                 }
  1144.             }
  1145.             
  1146.             // Controllo sul namespace RPC.
  1147.             if(namespaceRPC!=null && rpcElement!=null){
  1148.                 this.logger.debug("CheckRPCNamespace");
  1149.                 
  1150.                 if( (rpcElement.getNamespaceURI()==null || StringUtils.isEmpty(rpcElement.getNamespaceURI())) ){
  1151.                     if(!this.rpcAcceptRootElementUnqualified) {
  1152.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1153.                             throw new WSDLValidatorException("Unqualified rpc "+(isRichiesta?"request":"response")+" element '"+rpcElement.getLocalName()+"' by WSDL specification '"+uriAccordo+"' (port-type:"+portType+", operation:"+operation+")");
  1154.                         }else{
  1155.                             throw new WSDLValidatorException("Unqualified rpc "+(isRichiesta?"request":"response")+" element '"+rpcElement.getLocalName()+"' by API specification '"+uriAccordo+"' (service:"+portType+", operation:"+operation+")");
  1156.                         }
  1157.                     }
  1158.                 }
  1159.                 else {
  1160.                     if(!rpcElement.getNamespaceURI().equals(namespaceRPC)){
  1161.                         if(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()){
  1162.                             throw new WSDLValidatorException("Invalid rpc "+(isRichiesta?"request":"response")+" element '"+rpcElement.getLocalName()+"' by WSDL specification '"+uriAccordo+"' (port-type:"+portType+", operation:"+operation+"): expected namespace '"+namespaceRPC+"'; found namespace '"+rpcElement.getNamespaceURI()+"'");
  1163.                         }else{
  1164.                             throw new WSDLValidatorException("Invalid rpc "+(isRichiesta?"request":"response")+" element '"+rpcElement.getLocalName()+"' by API specification '"+uriAccordo+"' (service:"+portType+", operation:"+operation+"): expected namespace '"+namespaceRPC+"'; found namespace '"+rpcElement.getNamespaceURI()+"'");
  1165.                         }
  1166.                     }
  1167.                 }
  1168.             }
  1169.             
  1170.         }catch(Exception e){
  1171.             String msgErrore = "Validazione WSDL ("+isRichiesta+") fallita: "+e.getMessage();
  1172.             if(logErrorAsDebug){
  1173.                 this.logger.debug(msgErrore);
  1174.             }else{
  1175.                 this.logger.error(msgErrore,e);
  1176.             }
  1177.             if( (e instanceof WSDLValidatorException)==false )
  1178.                 this.logger.debug("Validazione WSDL fallita",e);
  1179.             // è gia nella definizione dell'error
  1180.             StringBuilder errorMsgValidazioneXSDBuilder = new StringBuilder();
  1181.             if(this.addPrefixError) {
  1182.                 if(isRichiesta) {
  1183.                     errorMsgValidazioneXSDBuilder.append("Request");
  1184.                 }
  1185.                 else {
  1186.                     errorMsgValidazioneXSDBuilder.append("Response");
  1187.                 }
  1188.                 errorMsgValidazioneXSDBuilder.append(" content not conform to ").append(this.accordoServizioWrapper.isPortTypesLoadedFromWSDL()?"WSDL":"API").append(" specification; ");
  1189.             }
  1190.             errorMsgValidazioneXSDBuilder.append(e.getMessage());
  1191.             errorMsgValidazioneXSD = errorMsgValidazioneXSDBuilder.toString();
  1192.         }
  1193.         if(errorMsgValidazioneXSD!=null){
  1194.             throw new WSDLValidatorException(errorMsgValidazioneXSD);
  1195.         }
  1196.         
  1197.     }
  1198.     
  1199.     
  1200.     
  1201.     
  1202.     
  1203.     
  1204.     
  1205.     
  1206.     
  1207.     /* -------------- VALIDAZIONE UTILITIES --------------------- */
  1208.     
  1209.     public Element cleanXSITypes(Node node) throws Exception{
  1210.         
  1211.         //La versione non e' rilevante.
  1212.         byte[] element = this.eraserType (this.xmlUtils.toByteArray(node,true));
  1213.         Document doc = this.xmlUtils.newDocument(element);
  1214.         Element domElem = doc.getDocumentElement();
  1215.         
  1216.         /*  vecchia impl: 
  1217.         MessageElement daClonare = (MessageElement) node;
  1218.         //System.out.println("PRIMA ["+daClonare.getAsString()+"] ");
  1219.         byte[]element = this.eraserType(daClonare.getAsString().getBytes());
  1220.         //System.out.println("DOPO ["+new String(element)+"] ");
  1221.         Element e =  XMLUtils.newElement(element);
  1222.         */
  1223.         
  1224.         return domElem;
  1225.     }
  1226.     /**
  1227.      * Metodo che si occupa di effettuare l'eliminazione degli xsd:type String
  1228.      *
  1229.      * utility che elimina gli xsd type
  1230.      * @param xml Xml su cui effettuare la pulizia dell'header.
  1231.      * @return byte[] contenente un xml 'pulito'.
  1232.      * 
  1233.      */
  1234.     public byte[] eraserType(byte[] xml) throws UtilsException{

  1236.         ByteArrayOutputStream cleanXML = null;
  1237.         String prefix = "";
  1238.         try{
  1239.             cleanXML = new ByteArrayOutputStream();

  1241.             // Elimino import
  1242.             for(int i=0; i<xml.length ; ){

  1244.                 if(xml[i] == ' '){

  1246.                     // Cerco Stringa  " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
  1247.                     String importXSITYPE = "http://www.w3.org/2001/XMLSchema-instance"; 
  1248.                     if(i+"xmlns:".length() < xml.length){
  1249.                         if( (xml[i+1] == 'x') &&
  1250.                             (xml[i+2] == 'm') &&
  1251.                             (xml[i+3] == 'l') &&
  1252.                             (xml[i+4] == 'n') &&
  1253.                             (xml[i+5] == 's') &&
  1254.                             (xml[i+6] == ':')){
  1255.                             StringBuilder test = new StringBuilder("xmlns:");
  1256.                             StringBuilder prefixTest = new StringBuilder();
  1257.                             int contatoreFineAttributo = 0;
  1258.                             for(int k=7 ; ; k++){
  1259.                                 if((i+k)>=xml.length)
  1260.                                     break;
  1261.                                 if((char)xml[i+k] == '"')
  1262.                                     contatoreFineAttributo++;
  1263.                                 if(contatoreFineAttributo==0)
  1264.                                     prefixTest.append((char)xml[i+k]);
  1265.                                 test.append((char)xml[i+k]);
  1266.                                 if(contatoreFineAttributo>=2)
  1267.                                     break;
  1268.                             }
  1269.                             //System.out.println("TROVATO ["+test.toString()+"] PREFIX["+prefixTest.toString()+"]");
  1270.                             // Prelevo valore
  1271.                             int indexFirst = test.toString().indexOf('"');
  1272.                             int secondFirst = test.toString().indexOf('"', indexFirst+1);
  1273.                             String testEquals = test.toString().substring(indexFirst+1, secondFirst);
  1274.                             //System.out.println("TROVATO SUBSTRING ["+testEquals+"]");
  1275.                             if(importXSITYPE.equalsIgnoreCase(testEquals)){
  1276.                                 //System.out.println("CANCELLO");
  1277.                                 prefix = prefixTest.toString().substring(0, prefixTest.length()-1);
  1278.                                 //System.out.println("CANCELLO P["+prefix+"]");
  1279.                                 // Cancello la stringa trovata
  1280.                                 i = i + test.toString().length() +1;
  1281.                                 continue;
  1282.                             }
  1283.                         }
  1284.                     }
  1285.                     
  1286.                     cleanXML.write(xml[i]);
  1287.                     i++;

  1289.                 }else{
  1290.                     cleanXML.write(xml[i]);
  1291.                     i++;
  1292.                 }

  1294.             }
  1295.             byte [] risultato = cleanXML.toByteArray();
  1296.             cleanXML = new ByteArrayOutputStream();
  1297.             //System.out.println("DOPO step 1 ["+new String(risultato)+"] ");
  1298.             cleanXML.close();
  1299.             
  1300.             // Elimino xsi type
  1301.             for(int i=0; i<risultato.length ; ){

  1303.                 if(risultato[i] == ' '){

  1305.                     // Cerco Stringa  " xsi:type=\"xsd:TYPE\""
  1306.                     String XSITYPE_PREFIX = prefix+":type=\""; 
  1307.                     if(i+XSITYPE_PREFIX.length()+2 < risultato.length){
  1308.                         StringBuilder test = new StringBuilder("");
  1309.                         int contatoreFineAttributo = 0;
  1310.                         for(int k=1 ; ; k++){
  1311.                             if((i+k)>=risultato.length)
  1312.                                 break;
  1313.                             if((char)risultato[i+k] == '"')
  1314.                                 contatoreFineAttributo++;
  1315.                             test.append((char)risultato[i+k]);
  1316.                             if(contatoreFineAttributo>=2)
  1317.                                 break;
  1318.                         }
  1319.                         //stem.out.println("TROVATO ["+test.toString()+"] START WITH["+XSITYPE_PREFIX+"]");
  1320.                         if(test.toString().startsWith(XSITYPE_PREFIX)){
  1321.                             // Cancello la stringa trovata
  1322.                             //System.out.println("CANCELLO");
  1323.                             i = i + test.toString().length()+1;
  1324.                             continue;
  1325.                         }
  1326.                     }
  1327.                     
  1328.                     cleanXML.write(risultato[i]);
  1329.                     i++;

  1331.                 }else{
  1332.                     cleanXML.write(risultato[i]);
  1333.                     i++;
  1334.                 }

  1336.             }
  1337.             risultato = cleanXML.toByteArray();
  1338.             cleanXML.close();
  1339.             
  1340.             return risultato;

  1342.         } catch(Exception e) {
  1343.             this.logger.error("Utilities.eraserType",e);
  1344.             try{
  1345.                 if(cleanXML!=null)
  1346.                     cleanXML.close();
  1347.             }catch(Exception eis){
  1348.                 // ignore
  1349.             }
  1350.             throw new UtilsException("Eliminazione xsi:type per validazione non riuscita "+e.getMessage(),e);
  1351.         }
  1352.     }  
  1353.     
  1354.     
  1355.     
  1356.     
  1357.     
  1358.     

  1360. }

  1362. class RootElementBody{
  1363.     
  1364.     private String localName;
  1365.     private String namespace;
  1366.     private String xsiType;
  1367.     
  1368.     // Questo elemento viene valorizzato solo nei casi di wsdl encoded dove gli elementi vengono definiti con wsdl:part element e non type.
  1369.     private String namespaceElementoCheContieneXSIType;
  1370.         
  1371.     public RootElementBody(SOAPEnvelope soapEnvelope,Node nodoPadre,boolean rpc, Node n) throws Exception{
  1372.         
  1373.         NamedNodeMap attributes = n.getAttributes();
  1374.         this.localName = n.getLocalName();
  1375.         
  1376.         // Prima verifico presenza di xsi:types ...
  1377.         if(attributes!=null && attributes.getLength()>0){
  1378.             for (int i = 0; i < attributes.getLength(); i++) {
  1379.                 Node attribute = attributes.item(i);
  1380.                 if(attribute instanceof Attr){
  1381.                     Attr a = (Attr) attribute;
  1382.                     //String attrName = a.getName(); // type
  1383.                     //String attrPrefix = a.getPrefix(); // xsi
  1384.                     String attrLocalName = a.getLocalName();
  1385.                     String attrNamespace = a.getNamespaceURI(); // http://www.w3.org/2001/XMLSchema-instance
  1386.                     String value = a.getNodeValue(); // messaggioSII:esitoProcessMessaggioSIIType
  1387.                     //System.out.println("ATTRNAME["+attrName+"] ATTRPREFIX["+attrPrefix+"] ATTRNAMESPACE["+attrNamespace+"] VALUE["+value+"]");
  1388.                     if(WSDLValidator.XMLSCHEMA_INSTANCE_NAMESPACE.equals(attrNamespace) &&
  1389.                             WSDLValidator.XMLSCHEMA_INSTANCE_LOCAL_NAME_TYPE.equals(attrLocalName) && 
  1390.                             value!=null){
  1391.                         String prefix = "";
  1392.                         String typeName = value;
  1393.                         if(value.contains(":")){
  1394.                             prefix = value.split(":")[0];
  1395.                             typeName = value.split(":")[1];
  1396.                         }
  1397.                         this.xsiType = typeName;
  1398.                         
  1399.                         // Cerco namespace corrispondente al prefix.
  1400.                         // 1. cerco prima nel nodo stesso
  1401.                         this.namespace = this.mappingPrefixToNamespace(n, prefix);
  1402.                         if(this.namespace==null){
  1403.                             if(rpc){
  1404.                                 // 2. cerco nel rpc element
  1405.                                 this.namespace = this.mappingPrefixToNamespace(nodoPadre, prefix);
  1406.                                 if(this.namespace==null){
  1407.                                     // 3. cerco nel soap body
  1408.                                     this.namespace = this.mappingPrefixToNamespace(soapEnvelope.getBody(), prefix);
  1409.                                     if(this.namespace==null){
  1410.                                         // 4. cerco nel soap envelope
  1411.                                         this.namespace = this.mappingPrefixToNamespace(soapEnvelope, prefix);
  1412.                                         if(this.namespace==null){
  1413.                                             throw new Exception("[RPCStyle] Namespace (for prefix "+prefix+") not found for element ["+n.getLocalName()+"] with xsi:type=\""+value+"\"");
  1414.                                         }
  1415.                                     }   
  1416.                                 }
  1417.                             }else{
  1418.                                 // 2. cerco nel soap body (il nodo padre)
  1419.                                 this.namespace = this.mappingPrefixToNamespace(nodoPadre, prefix);
  1420.                                 if(this.namespace==null){
  1421.                                     // 3. cerco nel soap envelope
  1422.                                     this.namespace = this.mappingPrefixToNamespace(soapEnvelope, prefix);
  1423.                                     if(this.namespace==null){
  1424.                                         throw new Exception("[DocumentStyle] Namespace (for prefix "+prefix+") not found for element ["+n.getLocalName()+"] with xsi:type=\""+value+"\"");
  1425.                                     }
  1426.                                 }   
  1427.                             }
  1428.                         }
  1429.                     }
  1430.                 }
  1431.             }
  1432.         }
  1433.         
  1434.         if(this.xsiType==null){
  1435.             this.namespace = n.getNamespaceURI();
  1436.         }
  1437.         else{
  1438.             this.namespaceElementoCheContieneXSIType = n.getNamespaceURI();
  1439.         }
  1440.     }
  1441.     
  1442.     private String mappingPrefixToNamespace(Node n,String prefix) {
  1443.         NamedNodeMap attributes = n.getAttributes();
  1444.         if(attributes==null || attributes.getLength()<=0){
  1445.             return null;
  1446.         }
  1447.         for (int i = 0; i < attributes.getLength(); i++) {
  1448.             Node attribute = attributes.item(i);
  1449.             if(attribute instanceof Attr){
  1450.                 Attr a = (Attr) attribute;
  1451.                 String attrName = a.getName(); // type
  1452.                 //String attrPrefix = a.getPrefix(); // xsi
  1453.                 //String attrNamespace = a.getNamespaceURI(); // http://www.w3.org/2001/XMLSchema-instance
  1454.                 String value = a.getNodeValue(); // messaggioSII:esitoProcessMessaggioSIIType
  1455.                 //System.out.println("CHECK XMLNS Search["+prefix+"] ATTRNAME["+attrName+"] ATTRPREFIX["+attrPrefix+"] ATTRNAMESPACE["+attrNamespace+"] VALUE["+value+"]");
  1456.                 
  1457.                 if(attrName.startsWith("xmlns")){
  1458.                 
  1459.                     if(prefix==null || prefix.equals("")){
  1460.                         if("xmlns".equals(attrName)){
  1461.                             //System.out.println("FOUND! ["+value+"]");
  1462.                             return value;
  1463.                         }
  1464.                     }
  1465.                     else{
  1466.                         if(attrName.equals("xmlns:"+prefix)){
  1467.                             //System.out.println("FOUND! ["+value+"]");
  1468.                             return value;
  1469.                         }
  1470.                     }
  1471.                     
  1472.                 }
  1473.                 
  1474.             }
  1475.         }
  1476.         return null;
  1477.     }
  1478.     
  1479.     public String getLocalName() {
  1480.         return this.localName;
  1481.     }
  1482.     public void setLocalName(String localName) {
  1483.         this.localName = localName;
  1484.     }
  1485.     public String getNamespace() {
  1486.         return this.namespace;
  1487.     }
  1488.     public void setNamespace(String namespace) {
  1489.         this.namespace = namespace;
  1490.     }
  1491.     public String getXsiType() {
  1492.         return this.xsiType;
  1493.     }
  1494.     public void setXsiType(String xsiType) {
  1495.         this.xsiType = xsiType;
  1496.     }
  1497.     public String getNamespaceElementoCheContieneXSIType() {
  1498.         return this.namespaceElementoCheContieneXSIType;
  1499.     }
  1500.     public void setNamespaceElementoCheContieneXSIType(
  1501.             String namespaceElementoCheContieneXSIType) {
  1502.         this.namespaceElementoCheContieneXSIType = namespaceElementoCheContieneXSIType;
  1503.     }
  1504.     
  1505.     @Override
  1506.     public String toString(){
  1507.         return RootElementBody.toString(this.localName, this.namespace, this.xsiType, this.namespaceElementoCheContieneXSIType);
  1508.     }
  1509.     
  1510.     public static String toString(String localName,String namespace,String xsiType){
  1511.         return toString(localName, namespace, xsiType, null);
  1512.     }
  1513.     private static String toString(String localName,String namespace,String xsiType,String namespaceElementoCheContieneXSIType){
  1514.         StringBuilder bf = new StringBuilder();
  1515.         if(xsiType==null){
  1516.             bf.append("{");
  1517.             bf.append(namespace);
  1518.             bf.append("}");
  1519.             bf.append(localName);
  1520.         }else{
  1521.             bf.append("[xsi:type=\"{");
  1522.             bf.append(namespace);
  1523.             bf.append("\"}"+xsiType+"]");
  1524.             // Questo elemento viene valorizzato solo nei casi di wsdl encoded dove gli elementi vengono definiti con wsdl:part element e non type.
  1525.             if(namespaceElementoCheContieneXSIType!=null){
  1526.                 bf.append("{");
  1527.                 bf.append(namespaceElementoCheContieneXSIType);
  1528.                 bf.append("}");
  1529.             }
  1530.             bf.append(localName);
  1531.         }
  1532.         return bf.toString();
  1533.     }
  1534. }
Created with JaCoCo 0.8.8.202204050719