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



  23. package org.openspcoop2.utils.wsdl;

  25. import java.io.ByteArrayOutputStream;
  26. import java.io.File;
  27. import java.io.FileOutputStream;
  28. import java.io.FileWriter;
  29. import java.io.IOException;
  30. import java.io.OutputStream;
  31. import java.io.Writer;
  32. import java.net.URI;
  33. import java.util.ArrayList;
  34. import java.util.HashMap;
  35. import java.util.List;

  37. import javax.wsdl.Binding;
  38. import javax.wsdl.Definition;
  39. import javax.wsdl.Port;
  40. import javax.wsdl.Service;
  41. import javax.wsdl.Types;
  42. import javax.wsdl.WSDLException;
  43. import javax.wsdl.extensions.schema.Schema;
  44. import javax.xml.namespace.QName;
  45. import javax.xml.transform.TransformerException;

  47. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  48. import org.openspcoop2.utils.xml.DynamicNamespaceContext;
  49. import org.openspcoop2.utils.xml.PrettyPrintXMLUtils;
  50. import org.openspcoop2.utils.xml.XMLException;
  51. import org.openspcoop2.utils.xml.XPathExpressionEngine;
  52. import org.openspcoop2.utils.xml.XPathNotFoundException;
  53. import org.openspcoop2.utils.xml.XPathReturnType;
  54. import org.openspcoop2.utils.xml.XSDUtils;
  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.NodeList;
  62. import org.w3c.dom.Text;

  64. import com.ibm.wsdl.xml.WSDLReaderImpl;
  65. import com.ibm.wsdl.xml.WSDLWriterImpl;



  69. /**
  70.  * Utilities per i WSDL
  71.  *
  72.  *
  73.  * @author Poli Andrea (apoli@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */


  79. public class WSDLUtilities {

  81.     
  82. //  public static WSDLUtilities getInstance(){
  83. //      return new WSDLUtilities(null); // senza xmlUtils
  84. //  }
  85.     public static WSDLUtilities getInstance(AbstractXMLUtils xmlUtils){
  86.         return new WSDLUtilities(xmlUtils); 
  87.     }
  88.     
  89.     
  90.     

  92.     private AbstractXMLUtils xmlUtils = null;
  93.     public WSDLUtilities(AbstractXMLUtils xmlUtils){
  94.         this.xmlUtils = xmlUtils;
  95.     }
  96.     
  97.     
  98.     
  99.     
  100.     
  101.     
  102.     /* ---------------- METODI STATICI PUBBLICI ------------------------- */
  103.     
  104.     /** WSDLReader */
  105.     public WSDLReaderImpl getWSDLReader(boolean verbose,boolean importDocuments){
  106.         WSDLReaderImpl wsdlReader = new WSDLReaderImpl();
  107.         wsdlReader.setFeature("javax.wsdl.verbose", verbose);
  108.         wsdlReader.setFeature("javax.wsdl.importDocuments", importDocuments);
  109.         return wsdlReader;
  110.     }
  111.     
  112.     
  113.     
  114.     // IS WSDL
  115.     public boolean isWSDL(byte[]wsdl) throws org.openspcoop2.utils.wsdl.WSDLException {
  116.         try{
  117.             if(this.xmlUtils==null){
  118.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  119.             }
  120.             
  121.             if(!this.xmlUtils.isDocument(wsdl)){
  122.                 return false;
  123.             }
  124.             Document docXML = this.xmlUtils.newDocument(wsdl);
  125.             Element elemXML = docXML.getDocumentElement();
  126.             return isWSDL(elemXML);
  127.         }catch(Exception e){
  128.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  129.         }
  130.     }
  131.     public boolean isWSDL(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException {
  132.         Element elemXML = wsdl.getDocumentElement();
  133.         return isWSDL(elemXML);
  134.     }
  135.     
  136.     public boolean isWSDL(Element wsdl) throws org.openspcoop2.utils.wsdl.WSDLException {
  137.         return isWSDL((Node)wsdl);
  138.     }
  139.     public boolean isWSDL(Node wsdl) throws org.openspcoop2.utils.wsdl.WSDLException {
  140.         try{
  141.             if(wsdl == null){
  142.                 throw new Exception("Documento wsdl da verificare non definito");
  143.             }
  144.             //System.out.println("LOCAL["+wsdl.getLocalName()+"]  NAMESPACE["+wsdl.getNamespaceURI()+"]");
  145.             if(!"definitions".equals(wsdl.getLocalName())){
  146.                 return false;
  147.             }
  148.             if(!"http://schemas.xmlsoap.org/wsdl/".equals(wsdl.getNamespaceURI())){
  149.                 return false;
  150.             }
  151.             return true;
  152.         }catch(Exception e){
  153.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  154.         }
  155.     }
  156.     
  157.     
  158.     
  159.     
  160.     // TARGET NAMESPACE
  161.     
  162.     public String getTargetNamespace(byte[]xsd) throws org.openspcoop2.utils.wsdl.WSDLException {
  163.         try{
  164.             if(this.xmlUtils==null){
  165.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  166.             }
  167.             
  168.             if(!this.xmlUtils.isDocument(xsd)){
  169.                 throw new Exception("Wsdl non e' un documento valido");
  170.             }
  171.             Document docXML = this.xmlUtils.newDocument(xsd);
  172.             Element elemXML = docXML.getDocumentElement();
  173.             return getTargetNamespace(elemXML);
  174.         }catch(Exception e){
  175.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  176.         }
  177.     }
  178.     
  179.     public String getTargetNamespace(Document xsd) throws org.openspcoop2.utils.wsdl.WSDLException {
  180.         Element elemXML = xsd.getDocumentElement();
  181.         return getTargetNamespace(elemXML);
  182.     }
  183.     
  184.     public String getTargetNamespace(Element elemXML) throws org.openspcoop2.utils.wsdl.WSDLException {
  185.         return getTargetNamespace((Node)elemXML);
  186.     }
  187.     
  188.     public String getTargetNamespace(Node elemXML) throws org.openspcoop2.utils.wsdl.WSDLException {
  189.         try{
  190.             if(this.xmlUtils==null){
  191.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  192.             }
  193.             
  194.             if(elemXML == null){
  195.                 throw new Exception("Wsdl non e' un documento valido");
  196.             }
  197.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  198.             if(!"definitions".equals(elemXML.getLocalName())){
  199.                 throw new Exception("Root element non e' un definition wsdl ("+elemXML.getLocalName()+")");
  200.             }
  201.             String targetNamespace = this.xmlUtils.getAttributeValue(elemXML, "targetNamespace");
  202.             //System.out.println("TARGET["+targetNamespace+"]");
  203.             return targetNamespace;
  204.         }catch(Exception e){
  205.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  206.         }
  207.     }
  208.     
  209.     public String getTargetNamespace(Schema schema){
  210.         NamedNodeMap attributi = schema.getElement().getAttributes();
  211.         if(attributi!=null){
  212.             for(int i=0; i<attributi.getLength(); i++){
  213.                 Node a = attributi.item(i);
  214.                 //System.out.println("aaa ["+a.getLocalName()+"] ["+a.getPrefix()+"] ["+a.getNodeValue()+"]");
  215.                 if("targetNamespace".equals(a.getLocalName())){
  216.                     return a.getNodeValue();
  217.                 }
  218.             }
  219.         }
  220.         return null;
  221.     }
  222.     
  223.     
  224.     // IMPORT
  225.     public String getImportNamespace(Node elemXML) throws org.openspcoop2.utils.wsdl.WSDLException {
  226.         try{
  227.             if(this.xmlUtils==null){
  228.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  229.             }
  230.             if(elemXML == null){
  231.                 throw new Exception("Non e' un import valido");
  232.             }
  233.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  234.             if(!"import".equals(elemXML.getLocalName())){
  235.                 throw new Exception("Root element non e' un import wsdl ("+elemXML.getLocalName()+")");
  236.             }
  237.             String targetNamespace = this.xmlUtils.getAttributeValue(elemXML, "namespace");
  238.             //System.out.println("TARGET["+targetNamespace+"]");
  239.             return targetNamespace;
  240.         }catch(Exception e){
  241.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  242.         }
  243.     }
  244.     public String getImportLocation(Node elemXML) throws org.openspcoop2.utils.wsdl.WSDLException {
  245.         try{
  246.             if(this.xmlUtils==null){
  247.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  248.             }
  249.             if(elemXML == null){
  250.                 throw new Exception("Non e' un import valido");
  251.             }
  252.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  253.             if(!"import".equals(elemXML.getLocalName())){
  254.                 throw new Exception("Root element non e' un import wsdl ("+elemXML.getLocalName()+")");
  255.             }
  256.             String targetNamespace = this.xmlUtils.getAttributeValue(elemXML, "location");
  257.             //System.out.println("TARGET["+targetNamespace+"]");
  258.             return targetNamespace;
  259.         }catch(Exception e){
  260.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  261.         }
  262.     }
  263.     
  264.     // SCHEMA LOCATION
  265.     public void updateLocation(Node elemXML, String newLocation) throws org.openspcoop2.utils.wsdl.WSDLException {
  266.         
  267.         try{
  268.             if(this.xmlUtils==null){
  269.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  270.             }
  271.             if(elemXML == null){
  272.                 throw new Exception("Non e' un import valido");
  273.             }
  274.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  275.             if(!"import".equals(elemXML.getLocalName())){
  276.                 throw new Exception("Root element non e' un import wsdl ("+elemXML.getLocalName()+")");
  277.             }
  278.         
  279.             if(elemXML!=null && elemXML.getAttributes()!=null && elemXML.getAttributes().getLength()>0){
  280.                 
  281.     //          try{
  282.     //              System.out.println(" PRIMA: "+this.xmlUtils.toString(schemaImportInclude));
  283.     //          }catch(Exception e){System.out.println("ERRORE PRIMA");}
  284.                 
  285.                 Attr oldLocation = (Attr) elemXML.getAttributes().getNamedItem("location");
  286.                 this.xmlUtils.removeAttribute(oldLocation, (Element)elemXML);
  287.                 
  288.     //          try{
  289.     //              System.out.println(" REMOVE: "+this.xmlUtils.toString(schemaImportInclude));
  290.     //          }catch(Exception e){System.out.println("ERRORE REMOVE");}
  291.                 
  292.                 oldLocation.setValue(newLocation);
  293.                 this.xmlUtils.addAttribute(oldLocation, (Element)elemXML);
  294.                 
  295.     //          try{
  296.     //              System.out.println(" DOPO: "+this.xmlUtils.toString(schemaImportInclude));
  297.     //          }catch(Exception e){System.out.println("ERRORE DOPO");}
  298.             }
  299.         }catch(Exception e){
  300.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  301.         }
  302.     }
  303.     
  304.     
  305.     
  306.     
  307.     
  308.     
  309.     
  310.     
  311.     
  312.     /* ---------------- WRITE TO ------------------------- */
  313.     
  314.     public void writeWsdlTo(Definition wsdl, String absoluteFilename) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  315.         writeWsdlTo(wsdl,absoluteFilename,false);
  316.     }
  317.     public void writeWsdlTo(Definition wsdl, String absoluteFilename,boolean prettyPrint) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  318.         if(wsdl == null) return;
  319.         WSDLWriterImpl writer = new WSDLWriterImpl();
  320.         if(prettyPrint){
  321.             writeWsdlTo(wsdl, new File(absoluteFilename), prettyPrint);
  322.         }else{
  323.             writer.writeWSDL(wsdl, new FileWriter(absoluteFilename));
  324.         }
  325.     }
  326.     
  327.     public void writeWsdlTo(Definition wsdl, File file) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  328.         writeWsdlTo(wsdl,file,false);
  329.     }
  330.     public void writeWsdlTo(Definition wsdl, File file,boolean prettyPrint) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  331.         if(wsdl == null) return;
  332.         WSDLWriterImpl writer = new WSDLWriterImpl();
  333.         if(prettyPrint){
  334.             FileOutputStream fout = null;
  335.             try{
  336.                 fout = new FileOutputStream(file);
  337.                 writeWsdlTo(wsdl, fout, prettyPrint);
  338.             }finally{
  339.                 try{
  340.                     if(fout!=null) {
  341.                         fout.flush();
  342.                     }
  343.                 }catch(Exception eClose){}
  344.                 try{
  345.                     if(fout!=null) {
  346.                         fout.close();
  347.                     }
  348.                 }catch(Exception eClose){
  349.                     // close
  350.                 }
  351.             }
  352.         }else{
  353.             writer.writeWSDL(wsdl, new FileWriter(file));
  354.         }
  355.     }
  356.     
  357.     public void writeWsdlTo(Definition wsdl, OutputStream out) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  358.         writeWsdlTo(wsdl,out,false);
  359.     }
  360.     public void writeWsdlTo(Definition wsdl, OutputStream out,boolean prettyPrint) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  361.         if(wsdl == null) return;
  362.         WSDLWriterImpl writer = new WSDLWriterImpl();
  363.         if(prettyPrint){
  364.             out.write(prettyPrintWsdl(wsdl).getBytes());
  365.         }else{
  366.             writer.writeWSDL(wsdl, out);
  367.         }
  368.     }
  369.     
  370.     public void writeWsdlTo(Definition wsdl, Writer writer)throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  371.         writeWsdlTo(wsdl,writer,false);
  372.     }
  373.     public void writeWsdlTo(Definition wsdl, Writer writer,boolean prettyPrint)throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  374.         if(wsdl == null) return;
  375.         WSDLWriterImpl writerWsdl = new WSDLWriterImpl();
  376.         if(prettyPrint){
  377.             writer.append(prettyPrintWsdl(wsdl));
  378.         }else{
  379.             writerWsdl.writeWSDL(wsdl, writer);
  380.         }
  381.     }
  382.     
  383.     private String prettyPrintWsdl(Definition wsdl) throws WSDLException, IOException, org.openspcoop2.utils.wsdl.WSDLException{
  384.         try{
  385.             if(this.xmlUtils==null){
  386.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  387.             }
  388.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  389.             writeWsdlTo(wsdl, bout, false);
  390.             bout.flush();
  391.             bout.close();
  392.             Document wsdlDocument = this.xmlUtils.newDocument(bout.toByteArray());
  393.             return PrettyPrintXMLUtils.prettyPrintWithTrAX(wsdlDocument);
  394.         }catch(Exception e){
  395.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  396.         }
  397.     }
  398.     
  399.     
  400.     
  401.     
  402.     
  403.     /* ------------------ GENERAZIONE DEFINITION ---------------------------- */
  404.     /** NOTA: le importsDocument riguardano i WSDL Imports e non gli xsd imports!!!!!!! */
  405.     /**
  406.      * Legge un WSDL dal path in parametro e ne ritorna la Definition.
  407.      * @param file Il file da cui leggere il WSDL.
  408.      * @return La definition corretta o null in caso di path mancante o errori.
  409.      */
  410.     public Definition readWSDLFromFile(File file) throws WSDLException{
  411.         return readWSDLFromFile(file, false, true);
  412.     }
  413.     public Definition readWSDLFromFile(File file,boolean verbose,boolean importsDocument) throws WSDLException{
  414.         try{
  415.             if (file == null) throw new Exception("Path non definito");
  416.             WSDLReaderImpl reader = getWSDLReader(verbose, importsDocument);
  417.             try {
  418.                 Definition def = reader.readWSDL(file.getAbsolutePath());
  419.                 return def;
  420.             } catch (WSDLException e) {
  421.                 throw e;
  422.             }
  423.         }catch(Exception e){
  424.             throw new WSDLException("WSDLDefinitorio.readWSDLFromLocation(String path)","Lettura del wsdl non riuscita: "+e.getMessage());
  425.         }
  426.     }
  427.     /**
  428.      * Legge un WSDL dal path in parametro e ne ritorna la Definition.
  429.      * @param path Il path da cui leggere il WSDL.
  430.      * @return La definition corretta o null in caso di path mancante o errori.
  431.      */
  432.     public Definition readWSDLFromLocation(String path) throws WSDLException{
  433.         return readWSDLFromLocation(path, false, true);
  434.     }
  435.     public Definition readWSDLFromLocation(String path,boolean verbose,boolean importsDocument) throws WSDLException{
  436.         try{
  437.             if (path == null) throw new Exception("Path non definito");
  438.             WSDLReaderImpl reader = getWSDLReader(verbose, importsDocument);
  439.             try {
  440.                 Definition def = reader.readWSDL(path);
  441.                 return def;
  442.             } catch (WSDLException e) {
  443.                 throw e;
  444.             }
  445.         }catch(Exception e){
  446.             throw new WSDLException("WSDLDefinitorio.readWSDLFromLocation(String path)","Lettura del wsdl non riuscita: "+e.getMessage());
  447.         }
  448.     }
  449.     /**
  450.      * Legge un WSDL dal path in parametro e ne ritorna la Definition.
  451.      * @param wsdl I bytes da cui leggere il WSDL.
  452.      * @return La definition corretta o null in caso di path mancante o errori.
  453.      */
  454.     public Definition readWSDLFromBytes(byte[] wsdl) throws WSDLException{
  455.         return readWSDLFromBytes(wsdl, false, true);
  456.     }
  457.     public Definition readWSDLFromBytes(byte[] wsdl,boolean verbose,boolean importsDocument) throws WSDLException{
  458.         try{
  459.             if(this.xmlUtils==null){
  460.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  461.             }
  462.             if (wsdl == null) throw new Exception("Bytes non definiti");
  463.             WSDLReaderImpl reader = getWSDLReader(verbose, importsDocument);
  464.             try {
  465.                 Document document = this.xmlUtils.newDocument(wsdl);
  466.                 Definition def = reader.readWSDL(null,document);
  467.                 return def;
  468.             } catch (WSDLException e) {
  469.                 throw e;
  470.             }
  471.         }catch(Exception e){
  472.             throw new WSDLException("WSDLDefinitorio.readWSDLFromBytes(byte[] wsdl)","Lettura del wsdl non riuscita: "+e.getMessage());
  473.         }
  474.     }
  475.     /**
  476.      * Legge un WSDL dal path in parametro e ne ritorna la Definition.
  477.      * @param doc Document da cui leggere il WSDL.
  478.      * @return La definition corretta o null in caso di path mancante o errori.
  479.      */
  480.     public Definition readWSDLFromDocument(Document doc) throws WSDLException{
  481.         return readWSDLFromDocument(doc, false, true);
  482.     }
  483.     public Definition readWSDLFromDocument(Document doc,boolean verbose,boolean importsDocument) throws WSDLException{
  484.         try{
  485.             if (doc == null) throw new Exception("Document non definito");
  486.             WSDLReaderImpl reader = getWSDLReader(verbose, importsDocument);
  487.             try {
  488.                 Definition def = reader.readWSDL(null,doc);
  489.                 return def;
  490.             } catch (WSDLException e) {
  491.                 throw e;
  492.             }
  493.         }catch(Exception e){
  494.             throw new WSDLException("WSDLDefinitorio.readWSDLFromDocument(Document doc)","Lettura del wsdl non riuscita: "+e.getMessage());
  495.         }
  496.     }
  497.     /**
  498.      * Legge un WSDL dal path in parametro e ne ritorna la Definition.
  499.      * @param elem Element da cui leggere il WSDL.
  500.      * @return La definition corretta o null in caso di path mancante o errori.
  501.      */
  502.     public Definition readWSDLFromElement(Element elem) throws WSDLException{
  503.         return readWSDLFromElement(elem, false, true);
  504.     }
  505.     public Definition readWSDLFromElement(Element elem,boolean verbose,boolean importsDocument) throws WSDLException{
  506.         try{
  507.             if (elem == null) throw new Exception("Element non definito");
  508.             WSDLReaderImpl reader = getWSDLReader(verbose, importsDocument);
  509.             try {
  510.                 String param = null;
  511.                 Definition def = reader.readWSDL(param,elem);
  512.                 return def;
  513.             } catch (WSDLException e) {
  514.                 throw e;
  515.             }
  516.         }catch(Exception e){
  517.             throw new WSDLException("WSDLDefinitorio.readWSDLFromElement(Element elem)","Lettura del wsdl non riuscita: "+e.getMessage());
  518.         }
  519.     }
  520.     /**
  521.      * Legge un WSDL dal path in parametro e ne ritorna la Definition.
  522.      * @param uri La URI da cui leggere il WSDL.
  523.      * @return La definition corretta o null in caso di path mancante o errori.
  524.      */
  525.     public Definition readWSDLFromURI(URI uri) throws WSDLException{
  526.         return readWSDLFromURI(uri, false, true);
  527.     }
  528.     public Definition readWSDLFromURI(URI uri,boolean verbose,boolean importsDocument) throws WSDLException{
  529.         try{
  530.             if (uri == null) throw new Exception("URI non definita");
  531.             WSDLReaderImpl reader = getWSDLReader(verbose, importsDocument);
  532.             try {
  533.                 Definition def = reader.readWSDL(null,uri.getPath());
  534.                 return def;
  535.             } catch (WSDLException e) {
  536.                 throw e;
  537.             }
  538.         }catch(Exception e){
  539.             throw new WSDLException("WSDLDefinitorio.readWSDLFromURI(URI uri)","Lettura del wsdl non riuscita: "+e.getMessage());
  540.         }
  541.     }
  542.     
  543.     
  544.     
  545.     
  546.     
  547.     
  548.     
  549.     /* ------------------ READ URL ---------------------------- */
  550.     
  551.     public String getServiceEndpoint(byte [] wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  552.         return this.getServiceEndpoint(wsdl, null);
  553.     }
  554.     public String getServiceEndpoint(byte [] wsdl, String portType) throws org.openspcoop2.utils.wsdl.WSDLException{
  555.         try{
  556.             Document d = this.xmlUtils.newDocument(wsdl);
  557.             this.removeImports(d);
  558.             this.removeSchemiIntoTypes(d);
  559.             return this.getServiceEndpoint(new DefinitionWrapper(d, this.xmlUtils, false, false),portType);
  560.         }catch(Exception e){
  561.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  562.         }
  563.     }
  564.     public String getServiceEndpoint(Definition wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  565.         return this.getServiceEndpoint(wsdl, null);
  566.     }
  567.     public String getServiceEndpoint(Definition wsdl, String portType) throws org.openspcoop2.utils.wsdl.WSDLException{
  568.         try {
  569.             return this.getServiceEndpoint(new DefinitionWrapper(wsdl, this.xmlUtils),portType);
  570.         }catch(Exception e){
  571.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  572.         }
  573.     }
  574.     public String getServiceEndpoint(DefinitionWrapper wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  575.         return this.getServiceEndpoint(wsdl, null);
  576.     }
  577.     public String getServiceEndpoint(DefinitionWrapper wsdl, String portType) throws org.openspcoop2.utils.wsdl.WSDLException{
  578.         try {
  579.             if(wsdl==null || wsdl.getServices()==null || wsdl.getServices().isEmpty()) {
  580.                 return null;
  581.             }
  582.             if(portType==null) {
  583.                 if(wsdl.getServices().size()>1) {
  584.                     throw new Exception("Found more than one service, select port type");
  585.                 }
  586.                 Service service = (Service) wsdl.getServices().values().iterator().next();
  587.                 if(service.getPorts()==null || service.getPorts().isEmpty()) {
  588.                     return null;
  589.                 }
  590.                 if(service.getPorts().size()>1) {
  591.                     throw new Exception("Found more than one port, select port type");
  592.                 }
  593.                 List<?> list = ((Port) service.getPorts().values().iterator().next()).getExtensibilityElements();
  594.                 if(list==null || list.isEmpty()) {
  595.                     return null;
  596.                 } 
  597.                 for (Object object : list) {
  598.                     if(object instanceof  javax.wsdl.extensions.soap.SOAPAddress) {
  599.                         javax.wsdl.extensions.soap.SOAPAddress addr = (javax.wsdl.extensions.soap.SOAPAddress) object;
  600.                         return addr.getLocationURI();
  601.                     }
  602.                     else if(object instanceof  javax.wsdl.extensions.soap12.SOAP12Address) {
  603.                         javax.wsdl.extensions.soap12.SOAP12Address addr = (javax.wsdl.extensions.soap12.SOAP12Address) object;
  604.                         return addr.getLocationURI();
  605.                     }
  606.                 }
  607.                 return null;
  608.             }
  609.             else {
  610.                 if(wsdl.getPortTypes()==null || wsdl.getPortTypes().isEmpty()) {
  611.                     return null;
  612.                 }
  613.                 QName qNamePT = null;
  614.                 for (Object o : wsdl.getPortTypes().keySet()) {
  615.                     if(o instanceof QName) {
  616.                         QName qName = (QName) o;
  617.                         if(portType.equals(qName.getLocalPart())) {
  618.                             qNamePT = qName;
  619.                             break;
  620.                         }
  621.                     }
  622.                 }
  623.                 if(qNamePT==null) {
  624.                     return null;
  625.                 }
  626.                 if(wsdl.getBindings()==null || wsdl.getBindings().isEmpty()) {
  627.                     return null;
  628.                 }
  629.                 QName qNameBinding = null;
  630.                 for (Object o : wsdl.getBindings().values()) {
  631.                     if(o instanceof Binding) {
  632.                         Binding bindingCheck = (Binding) o;
  633.                         if(bindingCheck.getPortType()!=null) {
  634.                             if(qNamePT.equals(bindingCheck.getPortType().getQName())) {
  635.                                 qNameBinding = bindingCheck.getQName();
  636.                                 break;
  637.                             }
  638.                         }
  639.                     }
  640.                 }
  641.                 if(qNameBinding==null) {
  642.                     return null;
  643.                 }
  644.                 for (Object o : wsdl.getServices().values()) {
  645.                     if(o instanceof Service) {
  646.                         Service serviceCheck = (Service) o;
  647.                         if(serviceCheck.getPorts()!=null && !serviceCheck.getPorts().isEmpty()) {
  648.                             for (Object oP : serviceCheck.getPorts().values()) {
  649.                                 if(oP instanceof Port) {
  650.                                     Port portCheck = (Port) oP;
  651.                                     if(portCheck.getBinding()!=null ) {
  652.                                         if(qNameBinding.equals(portCheck.getBinding().getQName())) {
  653.                                             List<?> list = portCheck.getExtensibilityElements();
  654.                                             if(list==null || list.isEmpty()) {
  655.                                                 return null;
  656.                                             } 
  657.                                             for (Object object : list) {
  658.                                                 if(object instanceof  javax.wsdl.extensions.soap.SOAPAddress) {
  659.                                                     javax.wsdl.extensions.soap.SOAPAddress addr = (javax.wsdl.extensions.soap.SOAPAddress) object;
  660.                                                     return addr.getLocationURI();
  661.                                                 }
  662.                                                 else if(object instanceof  javax.wsdl.extensions.soap12.SOAP12Address) {
  663.                                                     javax.wsdl.extensions.soap12.SOAP12Address addr = (javax.wsdl.extensions.soap12.SOAP12Address) object;
  664.                                                     return addr.getLocationURI();
  665.                                                 }
  666.                                             }       
  667.                                         }
  668.                                     }
  669.                                 }
  670.                             }
  671.                         }
  672.                     }
  673.                 }
  674.                 return null;
  675.             }
  676.         }catch(Exception e){
  677.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  678.         }
  679.     }
  680.     
  681.     
  682.     
  683.     
  684.     
  685.     /* ---------------- METODI ADD ------------------------- */
  686.     public void addSchemaIntoTypes(Document wsdl, Node schema) throws org.openspcoop2.utils.wsdl.WSDLException{
  687.         try{
  688.             NodeList list = wsdl.getChildNodes();
  689.             if(list!=null){
  690.                 for(int i=0; i<list.getLength(); i++){
  691.                     Node child = list.item(i);
  692.                     if("definitions".equals(child.getLocalName())){
  693.                         NodeList listDefinition = child.getChildNodes();
  694.                         if(listDefinition!=null){
  695.                             for(int j=0; j<listDefinition.getLength(); j++){
  696.                                 Node childDefinition = listDefinition.item(j);
  697.                                 if("types".equals(childDefinition.getLocalName())){
  698.                                     
  699.                                     childDefinition.appendChild(wsdl.createTextNode("\n\t\t"));
  700.                                     childDefinition.appendChild(schema);
  701.                                     childDefinition.appendChild(wsdl.createTextNode("\n"));
  702.                                     
  703.                                 }
  704.                             }
  705.                         }
  706.                     }
  707.                 }
  708.             }
  709.         }catch(Exception e){
  710.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante l'aggiunto di uno schema nell'elemento Types: "+e.getMessage(),e);
  711.         }
  712.     }
  713.     
  714.     public void addImportSchemaIntoTypes(Document wsdl, String targetNamespace, String location) throws org.openspcoop2.utils.wsdl.WSDLException{
  715.         
  716.         // NOTA: types deve esistere
  717.         
  718.         try{
  719.             NodeList list = wsdl.getChildNodes();
  720.             if(list!=null){
  721.                 for(int i=0; i<list.getLength(); i++){
  722.                     Node child = list.item(i);
  723.                     if("definitions".equals(child.getLocalName())){
  724.                         NodeList listDefinition = child.getChildNodes();
  725.                         if(listDefinition!=null){
  726.                             for(int j=0; j<listDefinition.getLength(); j++){
  727.                                 Node childDefinition = listDefinition.item(j);
  728.                                 if("types".equals(childDefinition.getLocalName())){
  729.                                     
  730.                                     Element importSchemaElement = wsdl.createElementNS("http://www.w3.org/2001/XMLSchema", "schema");
  731.                                     importSchemaElement.setAttribute("targetNamespace", targetNamespace);
  732.                                     
  733.                                     Element importElement = wsdl.createElementNS("http://www.w3.org/2001/XMLSchema", "import");
  734.                                     importElement.setAttribute("namespace", targetNamespace);
  735.                                     importElement.setAttribute("schemaLocation", location);
  736.                             
  737.                                     importSchemaElement.appendChild(wsdl.createTextNode("\n\t\t\t"));
  738.                                     importSchemaElement.appendChild(importElement);
  739.                                     importSchemaElement.appendChild(wsdl.createTextNode("\n\t\t"));
  740.                                     
  741.                                     childDefinition.appendChild(wsdl.createTextNode("\n\t\t"));
  742.                                     childDefinition.appendChild(importSchemaElement);
  743.                                     childDefinition.appendChild(wsdl.createTextNode("\n\n"));
  744.                                 }
  745.                             }
  746.                         }
  747.                     }
  748.                 }
  749.             }
  750.         }catch(Exception e){
  751.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante l'aggiunto di uno schema nell'elemento Types: "+e.getMessage(),e);
  752.         }
  753.     }
  754.     
  755.     
  756.     
  757.     
  758.     
  759.     
  760.     /* ---------------- METODI GET ------------------------- */
  761.             
  762.     public Node getIfExistsDefinitionsElementIntoWSDL(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  763.         
  764.         try{
  765.             NodeList list = wsdl.getChildNodes();
  766.             if(list!=null){
  767.                 for(int i=0; i<list.getLength(); i++){
  768.                     Node child = list.item(i);
  769.                     if("definitions".equals(child.getLocalName())){
  770.                         return child;
  771.                     }
  772.                 }
  773.             }
  774.             return null;
  775.         }catch(Exception e){
  776.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  777.         }
  778.     }
  779.         
  780.     

  782.     
  783.     
  784.     
  785.     
  786.     
  787.     /* ---------------- METODI READ IMPORTS ------------------------- */
  788.     
  789.     public List<Node> readImports(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  790.         
  791.         try{
  792.             List<Node> imports = new ArrayList<Node>();
  793.             
  794.             NodeList list = wsdl.getChildNodes();
  795.             if(list!=null){
  796.                 for(int i=0; i<list.getLength(); i++){
  797.                     Node child = list.item(i);
  798.                     if("definitions".equals(child.getLocalName())){
  799.                         NodeList listDefinition = child.getChildNodes();
  800.                         if(listDefinition!=null){
  801.                             for(int j=0; j<listDefinition.getLength(); j++){
  802.                                 Node childDefinition = listDefinition.item(j);
  803.                                 if("import".equals(childDefinition.getLocalName())){
  804.                                     imports.add(childDefinition);
  805.                                 }
  806.                             }
  807.                         }
  808.                     }
  809.                 }
  810.             }
  811.             return imports;
  812.         }catch(Exception e){
  813.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  814.         }
  815.     }
  816.     
  817.     public List<Node> readImportsAndIncludesSchemaIntoTypes(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  818.         return readImportsIncludesSchemaIntoTypes(wsdl,true,true);
  819.     }
  820.     public List<Node> readImportsSchemaIntoTypes(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  821.         return readImportsIncludesSchemaIntoTypes(wsdl,true,false);
  822.     }
  823.     public List<Node> readIncludesSchemaIntoTypes(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  824.         return readImportsIncludesSchemaIntoTypes(wsdl,false,true);
  825.     }
  826.     private List<Node> readImportsIncludesSchemaIntoTypes(Document wsdl,boolean readImport,boolean readInclude) throws org.openspcoop2.utils.wsdl.WSDLException{
  827.         
  828.         try{
  829.             if(this.xmlUtils==null){
  830.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  831.             }
  832.             XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  833.             
  834.             List<Node> imports = new ArrayList<Node>();
  835.             
  836.             NodeList list = wsdl.getChildNodes();
  837.             if(list!=null){
  838.                 for(int i=0; i<list.getLength(); i++){
  839.                     Node child = list.item(i);
  840.                     if("definitions".equals(child.getLocalName())){
  841.                         NodeList listDefinition = child.getChildNodes();
  842.                         if(listDefinition!=null){
  843.                             for(int j=0; j<listDefinition.getLength(); j++){
  844.                                 Node childDefinition = listDefinition.item(j);
  845.                                 if("types".equals(childDefinition.getLocalName())){
  846.                                     NodeList listTypes = childDefinition.getChildNodes();
  847.                                     if(listTypes!=null){
  848.                                         for(int h=0; h<listTypes.getLength(); h++){
  849.                                             Node childTypes = listTypes.item(h);
  850.                                             if("schema".equals(childTypes.getLocalName())){
  851.                                                 
  852.                                                 String targetNamespaceSchema = null;
  853.                                                 if(targetNamespaceSchema==null){
  854.                                                     try{
  855.                                                         targetNamespaceSchema = xsdUtils.getTargetNamespace(childTypes);
  856.                                                     }catch(Exception e){}
  857.                                                 }
  858.                                                 
  859.                                                 if(readImport){
  860.                                                     List<Node> importsSchemi = xsdUtils.readImports(targetNamespaceSchema,childTypes);
  861.                                                     if(importsSchemi!=null && importsSchemi.size()>0){
  862.                                                         imports.addAll(importsSchemi);
  863.                                                     }
  864.                                                 }
  865.                                                 if(readInclude){
  866.                                                     List<Node> includesSchemi = xsdUtils.readIncludes(targetNamespaceSchema,childTypes);
  867.                                                     if(includesSchemi!=null && includesSchemi.size()>0){
  868.                                                         imports.addAll(includesSchemi);
  869.                                                     }
  870.                                                 }
  871.                                                 
  872.                                             }
  873.                                         }
  874.                                     }
  875.                                 }
  876.                             }
  877.                         }
  878.                     }
  879.                 }
  880.             }
  881.             return imports;
  882.         }catch(Exception e){
  883.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  884.         }
  885.     }
  886.     
  887.     public List<Node> readImportsAndIncludesFromSchemaXSD(Schema xsd) throws org.openspcoop2.utils.wsdl.WSDLException{
  888.         try{
  889.             if(this.xmlUtils==null){
  890.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  891.             }
  892.             XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  893.             return xsdUtils.readImportsAndIncludes(getTargetNamespace(xsd),xsd.getElement());
  894.         }catch(Exception e){
  895.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  896.         }
  897.     }
  898.     public List<Node> readImportsFromSchemaXSD(Schema xsd) throws org.openspcoop2.utils.wsdl.WSDLException{
  899.         try{
  900.             if(this.xmlUtils==null){
  901.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  902.             }
  903.             XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  904.             return xsdUtils.readImports(getTargetNamespace(xsd),xsd.getElement());
  905.         }catch(Exception e){
  906.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  907.         }
  908.     }
  909.     public List<Node> readIncludesFromSchemaXSD(Schema xsd) throws org.openspcoop2.utils.wsdl.WSDLException{
  910.         try{
  911.             if(this.xmlUtils==null){
  912.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  913.             }
  914.             XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  915.             return xsdUtils.readIncludes(getTargetNamespace(xsd),xsd.getElement());
  916.         }catch(Exception e){
  917.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  918.         }
  919.     }
  920.     
  921.     
  922.     /**
  923.      * Recupera l'array dei documenti in xsd:include
  924.      * @param wsdlNormalizzato
  925.      * @return array dei documenti in xsd:include
  926.      * @throws IOException 
  927.      * @throws XMLException 
  928.      * @throws org.openspcoop2.utils.wsdl.WSDLException 
  929.      */
  930.     public List<byte[]> getSchemiXSD(Definition wsdlNormalizzato) throws IOException,TransformerException, XMLException, org.openspcoop2.utils.wsdl.WSDLException{
  931.         
  932.         if(this.xmlUtils==null){
  933.             throw new org.openspcoop2.utils.wsdl.WSDLException("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  934.         }
  935.         
  936.         // Il wsdl deve contenere solo schemi xsd completi
  937.         
  938.         List<byte[]> v = new ArrayList<byte[]>();
  939.         
  940.         Types types = wsdlNormalizzato.getTypes();
  941.         List<?> xsdTypes = types.getExtensibilityElements();
  942.         for (int i = 0; i< xsdTypes.size(); i++){
  943.             Schema schema = (Schema) xsdTypes.get(i);
  944.             v.add(this.xmlUtils.toByteArray(schema.getElement())); 
  945.         }
  946.         return v;
  947.         
  948.     }
  949.     
  950.     public List<Node> getSchemiXSD(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  951.         
  952.         try{
  953.             if(this.xmlUtils==null){
  954.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  955.             }
  956.             XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  957.             
  958.             List<Node> schemi = new ArrayList<Node>();
  959.             
  960.             NodeList list = wsdl.getChildNodes();
  961.             if(list!=null){
  962.                 for(int i=0; i<list.getLength(); i++){
  963.                     Node child = list.item(i);
  964.                     if("definitions".equals(child.getLocalName())){
  965.                         NodeList listDefinition = child.getChildNodes();
  966.                         if(listDefinition!=null){
  967.                             for(int j=0; j<listDefinition.getLength(); j++){
  968.                                 Node childDefinition = listDefinition.item(j);
  969.                                 if("types".equals(childDefinition.getLocalName())){
  970.                                     NodeList listTypes = childDefinition.getChildNodes();
  971.                                     if(listTypes!=null){
  972.                                         for(int h=0; h<listTypes.getLength(); h++){
  973.                                             Node childTypes = listTypes.item(h);
  974.                                             
  975.                                             if("schema".equals(childTypes.getLocalName()) && xsdUtils.isXSDSchema(childTypes) ){
  976.                                                 
  977.                                                 schemi.add(childTypes);
  978.                                                 
  979.                                             }
  980.                                         }
  981.                                     }
  982.                                 }
  983.                             }
  984.                         }
  985.                     }
  986.                 }
  987.             }
  988.             return schemi;
  989.         }catch(Exception e){
  990.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  991.         }
  992.     }
  993.     public List<byte[]> getBytesSchemiXSD(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  994.         List<Node> schemi = this.getSchemiXSD(wsdl);
  995.         
  996.         try{
  997.             if(this.xmlUtils==null){
  998.                 throw new Exception("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  999.             }
  1000.             List<byte[]> schemiBytes = new ArrayList<byte[]>();
  1001.             if(schemi!=null && schemi.size()>0){
  1002.                 for (Node node : schemi) {
  1003.                     schemiBytes.add(this.xmlUtils.toByteArray(node));       
  1004.                 }
  1005.             }
  1006.             return schemiBytes;
  1007.         }catch(Exception e){
  1008.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  1009.         }
  1010.     }
  1011.     
  1012.     
  1013.     
  1014.     
  1015.     
  1016.     
  1017.     /* ---------------- METODI NORMALIZZAZIONE ------------------------- */
  1018.     
  1019.     public String normalizzazioneSchemaPerInserimentoInWsdl(Element schemaXSD,Element wsdl,
  1020.             HashMap<String,String> prefixForWSDL,String uniquePrefixWSDL,boolean docImportato,String targetNamespaceParent) throws org.openspcoop2.utils.wsdl.WSDLException{
  1021.         
  1022.         String targetNamespace = null;
  1023.                 
  1024.         if(docImportato){
  1025.             
  1026.             // GESTIONE DOCUMENTO IMPORTATO
  1027.             //System.out.println("***** IMPORT");
  1028.             
  1029.             // Esamino targetNamespace e prefisso dell'xsd per verificarne la presenza nel definitions del wsdl
  1030.             targetNamespace = readPrefixForWsdl(schemaXSD, wsdl, prefixForWSDL, uniquePrefixWSDL, true);
  1031.         
  1032.             // Rimozione completa di tutti gli attributi all'infuori del TargetNamespace e dell'associato prefix
  1033.             NamedNodeMap attributi = schemaXSD.getAttributes();
  1034.             List<Attr> attributiDaMantenere = new ArrayList<Attr>();    
  1035.             if(attributi!=null && attributi.getLength()>0){
  1036.                 for (int i = (attributi.getLength()-1); i >= 0; i--) {
  1037.                     Attr attr = (Attr) attributi.item(i);
  1038.                     //System.out.println("REMOVE NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1039.                     /*
  1040.                      *  REMOVE NAME[xmlns:tns] LOCAL_NAME[tns] VALUE[http://example.ResponseError] URI[http://www.w3.org/2000/xmlns/]...
  1041.                         REMOVE NAME[xmlns:_p3_n4_tns] LOCAL_NAME[null] VALUE[http://example.ResponseError] URI[null]...
  1042.                         REMOVE NAME[xmlns:Q1] LOCAL_NAME[Q1] VALUE[http://example.libCodifiche] URI[http://www.w3.org/2000/xmlns/]...
  1043.                         REMOVE NAME[xmlns] LOCAL_NAME[xmlns] VALUE[http://www.w3.org/2001/XMLSchema] URI[http://www.w3.org/2000/xmlns/]...
  1044.                         REMOVE NAME[targetNamespace] LOCAL_NAME[targetNamespace] VALUE[http://example.ResponseError] URI[null]...
  1045.                         REMOVE NAME[elementFormDefault] LOCAL_NAME[elementFormDefault] VALUE[qualified] URI[null]...
  1046.                         REMOVE NAME[attributeFormDefault] LOCAL_NAME[attributeFormDefault] VALUE[unqualified] URI[null]...
  1047.                      **/
  1048.                     if(targetNamespace.equals(attr.getNodeValue()) || 
  1049.                             (!attr.getNodeName().equals("xmlns") && !attr.getNodeName().startsWith("xmlns:"))
  1050.                         ){
  1051.                         //System.out.println("REMOVE NON EFFETTUATO");
  1052.                         attributiDaMantenere.add(attr);
  1053.                     }
  1054.                     _correctPrefix(attr, targetNamespace, prefixForWSDL, schemaXSD, attributiDaMantenere);
  1055.                     
  1056.                     //schemaXSD.removeAttributeNode(attr);
  1057.                     this.xmlUtils.removeAttribute(attr, schemaXSD);
  1058.                 }
  1059.             }
  1060. //          IL Codice sotto non può funzionare, poichè in axiom la struttura NamedNodeMap non viene aggiornata dopo la remove
  1061. //          while(attributi.getLength()>0){
  1062. //              Attr attr = (Attr) attributi.item(0);
  1063. //              System.out.println("REMOVE NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1064. //              if(targetNamespace.equals(attr.getNodeValue())){
  1065. //                  System.out.println("REMOVE NON EFFETTUATO");
  1066. //                  attributiDaMantenere.add(attr);
  1067. //              }
  1068. //              schemaXSD.removeAttributeNode(attr);
  1069. //          }
  1070.             
  1071. //          // DEBUG DOPO ELIMINAZIONE
  1072. //          attributi = schemaXSD.getAttributes();
  1073. //          System.out.println("TEST: "+attributi.getLength());
  1074. //          for (int i = 0; i < attributi.getLength(); i++) {
  1075. //              Attr attr = (Attr) attributi.item(i);
  1076. //              System.out.println("TEST NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1077. //          }
  1078.             
  1079.             while(attributiDaMantenere.size()>0){
  1080.                 //schemaXSD.setAttributeNode(attributiDaMantenere.remove(0));
  1081.                 Attr attr = attributiDaMantenere.remove(0);
  1082.                 //System.out.println("RE-ADD NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1083.                 this.xmlUtils.addAttribute(attr, schemaXSD);
  1084.             }
  1085.             
  1086. //          // DEBUG DOPO AGGIUNTA
  1087. //          attributi = schemaXSD.getAttributes();
  1088. //          System.out.println("TEST2: "+attributi.getLength());
  1089. //          for (int i = 0; i < attributi.getLength(); i++) {
  1090. //              Attr attr = (Attr) attributi.item(i);
  1091. //              System.out.println("TEST2 NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1092. //          }
  1093.             
  1094.         }else{
  1095.             
  1096.             // GESTIONE DOCUMENTO INCLUSO
  1097.             //System.out.println("***** INCLUDE");
  1098.             
  1099.             targetNamespace = targetNamespaceParent;
  1100.             
  1101.             // Rimozione completa di tutti gli attributi 
  1102.             NamedNodeMap attributi = schemaXSD.getAttributes();
  1103.             List<Attr> attributiDaMantenere = new ArrayList<Attr>();    
  1104.             if(attributi!=null && attributi.getLength()>0){
  1105.                 for (int i = (attributi.getLength()-1); i >= 0; i--) {
  1106.                     Attr attr = (Attr) attributi.item(i);
  1107.                     //System.out.println("REMOVE NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1108.                     if(targetNamespace.equals(attr.getNodeValue()) || 
  1109.                             (!attr.getNodeName().equals("xmlns") && !attr.getNodeName().startsWith("xmlns:"))
  1110.                         ){
  1111.                         //System.out.println("REMOVE NON EFFETTUATO");
  1112.                         attributiDaMantenere.add(attr);
  1113.                     }
  1114.                     _correctPrefix(attr, targetNamespace, prefixForWSDL, schemaXSD, attributiDaMantenere);
  1115.                     
  1116.                     //schemaXSD.removeAttributeNode(attr);
  1117.                     this.xmlUtils.removeAttribute(attr, schemaXSD);
  1118.                 }
  1119.             }
  1120. //          IL Codice sotto non può funzionare, poichè in axiom la struttura NamedNodeMap non viene aggiornata dopo la remove
  1121. //          while(attributi.getLength()>0){
  1122. //              Attr attr = (Attr) attributi.item(0);
  1123. //              //System.out.println("REMOVE NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"]...");
  1124. //              schemaXSD.removeAttributeNode(attr);
  1125. //          }
  1126.             
  1127. //          // DEBUG DOPO ELIMINAZIONE
  1128. //          attributi = schemaXSD.getAttributes();
  1129. //          System.out.println("TEST: "+attributi.getLength());
  1130. //          for (int i = 0; i < attributi.getLength(); i++) {
  1131. //              Attr attr = (Attr) attributi.item(i);
  1132. //              System.out.println("TEST NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1133. //          }
  1134.             
  1135.             // Aggiungo targetNamespace e altri prefix associati al namespace
  1136.             boolean foundTargetNamespace = false;
  1137.             while(attributiDaMantenere.size()>0){
  1138.                 //schemaXSD.setAttributeNode(attributiDaMantenere.remove(0));
  1139.                 Attr attr = attributiDaMantenere.remove(0);
  1140.                 if("targetNamespace".equals(attr.getName())){
  1141.                     foundTargetNamespace = true;
  1142.                 }
  1143.                 //System.out.println("RE-ADD NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1144.                 this.xmlUtils.addAttribute(attr, schemaXSD);
  1145.             }
  1146.             if(!foundTargetNamespace){
  1147.                 schemaXSD.setAttribute("targetNamespace", targetNamespace);
  1148.             }
  1149.             
  1150. //          // DEBUG DOPO AGGIUNTA
  1151. //          attributi = schemaXSD.getAttributes();
  1152. //          System.out.println("TEST2: "+attributi.getLength());
  1153. //          for (int i = 0; i < attributi.getLength(); i++) {
  1154. //              Attr attr = (Attr) attributi.item(i);
  1155. //              System.out.println("TEST2 NAME["+attr.getName()+"] LOCAL_NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] URI["+attr.getNamespaceURI()+"]...");
  1156. //          }
  1157.         }
  1158.         
  1159.         return targetNamespace;
  1160.     }
  1161.     
  1162.     private void _correctPrefix(Attr attr, String targetNamespace, HashMap<String,String> prefixForWSDL, Element schemaXSD, List<Attr> attributiDaMantenere) throws org.openspcoop2.utils.wsdl.WSDLException {
  1163.         
  1164.         XPathExpressionEngine xpathEngine = null;
  1165.         DynamicNamespaceContext dnc = null;
  1166.         String exprType = "//*/@type";
  1167.         String exprRef = "//*/@ref";
  1168.         List<String> exprs = new ArrayList<>();
  1169.         exprs.add(exprType);
  1170.         exprs.add(exprRef);
  1171.         
  1172.         if(attr.getNodeName().startsWith("xmlns:") && attr.getLocalName()!=null) {
  1173.             if(!targetNamespace.equals(attr.getNodeValue())){ 
  1174.                 boolean found = false;
  1175.                 String prefixDest = null;
  1176.                 String prefixSrc = null;
  1177.                 for (String prefix: prefixForWSDL.keySet()) {
  1178.                     String value = prefixForWSDL.get(prefix);
  1179.                     if(value.equals(attr.getNodeValue())) {
  1180.                         found = true;
  1181.                         prefixSrc = attr.getLocalName();
  1182.                         if(prefix.startsWith("xmlns:")) {
  1183.                             prefixDest = prefix.substring("xmlns:".length());
  1184.                         }
  1185.                         else {
  1186.                             prefixDest = prefix;
  1187.                         }
  1188.                         break;
  1189.                     }
  1190.                 }
  1191.                 if(found) {
  1192.                     //System.out.println("DEVO FARE REPLACE DI PREFIX '"+prefixSrc+"' con '"+prefixDest+"'");
  1193.                     
  1194.                     for (String expr : exprs) {
  1195.                         if(xpathEngine==null) {
  1196.                             xpathEngine = new XPathExpressionEngine();
  1197.                             dnc = new DynamicNamespaceContext();
  1198.                             dnc.findPrefixNamespace(schemaXSD);
  1199.                         }
  1200.                         Object res = null;
  1201.                         try {
  1202.                             res = xpathEngine.getMatchPattern(schemaXSD, dnc, expr, XPathReturnType.NODESET);
  1203.                         }catch(XPathNotFoundException notFound) {
  1204.                         }
  1205.                         catch(Exception e) {
  1206.                             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  1207.                         }
  1208.                         if(res!=null) {
  1209.                             //System.out.println("XPATH RESULT ("+expr+"): "+res.getClass().getName());
  1210.                             if(res instanceof NodeList) {
  1211.                                 NodeList nodeList = (NodeList) res;
  1212.                                 for (int j = 0; j < nodeList.getLength(); j++) {
  1213.                                     Node n = nodeList.item(j);
  1214.                                     //System.out.println("i["+j+"] type["+n.getClass().getName()+"] value["+n.getNodeValue()+"]");
  1215.                                     if(n.getNodeValue()!=null && n.getNodeValue().startsWith(prefixSrc+":")) {
  1216.                                         n.setNodeValue(n.getNodeValue().replace(prefixSrc+":", prefixDest+":"));
  1217.                                     }
  1218.                                 }
  1219.                             }
  1220.                         }
  1221. //                      else {
  1222. //                          System.out.println("XPATH RESULT ("+expr+") NULL");
  1223. //                      }   
  1224.                     }
  1225.                     
  1226.                 }
  1227.                 else {
  1228.                     //System.out.println("REMOVE NON EFFETTUATO, DECL IN WSDL NON PRESENTE");
  1229.                     attributiDaMantenere.add(attr);
  1230.                 }
  1231.             }
  1232.         }
  1233.     }
  1234.     
  1235.     public String readPrefixForWsdl(Element schemaXSD,Element wsdl,
  1236.             HashMap<String,String> prefixForWSDL,String uniquePrefixWSDL,boolean targetNamespaceObbligatorio) throws org.openspcoop2.utils.wsdl.WSDLException{
  1237.             
  1238.         String targetNamespace = null;
  1239.         
  1240.         //System.out.println("TARGETNAMESPACE="+docElement.getNamespaceURI());
  1241.         NamedNodeMap attributi = schemaXSD.getAttributes();
  1242.         if(attributi!=null){
  1243.             // ricerca targetNamespace XSD
  1244.             for(int i=0; i<attributi.getLength(); i++){
  1245.                 Node attr = attributi.item(i);
  1246.                 //System.out.println("NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] PREFIX["+attr.getPrefix()+"]");
  1247.                 if("targetNamespace".equals(attr.getLocalName())){
  1248.                     targetNamespace =attr.getNodeValue();
  1249.                     break;
  1250.                 }
  1251.             }
  1252.             if(targetNamespace==null){
  1253.                 if(targetNamespaceObbligatorio)
  1254.                     throw new org.openspcoop2.utils.wsdl.WSDLException("Target namespace non trovato");
  1255.                 else
  1256.                     return null;
  1257.             }
  1258.             // ricerca prefisso associato al target namespace dell'XSD
  1259.             String prefixTargetNamespaceXSD = null;
  1260.             for(int i=0; i<attributi.getLength(); i++){
  1261.                 Node attr = attributi.item(i);
  1262.                 //System.out.println("NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] PREFIX["+attr.getPrefix()+"]");
  1263.                 if(targetNamespace.equals(attr.getNodeValue()) && "xmlns".equals(attr.getPrefix())){
  1264.                     //System.out.println("FOUND");
  1265.                     prefixTargetNamespaceXSD =attr.getLocalName();
  1266.                     break;
  1267.                 }
  1268.             }
  1269.             //System.out.println("PREFIX!!! ["+prefixTargetNamespaceXSD+"] ["+targetNamespaceXSD+"]");
  1270.             
  1271.             // Cerco il prefix nel definition del wsdl, ed in caso non sia definito lo registra per una successiva aggiunta
  1272.             NamedNodeMap attributi_wsdl = wsdl.getAttributes();
  1273.             if(attributi_wsdl!=null){
  1274.                 boolean findIntoWSDL = false;
  1275.                 for(int i=0; i<attributi_wsdl.getLength(); i++){
  1276.                     Node attr = attributi_wsdl.item(i);
  1277.                     //System.out.println("WSDL ATTR   NAME["+attr.getLocalName()+"] VALUE["+attr.getNodeValue()+"] PREFIX["+attr.getPrefix()+"]");
  1278.                     if(targetNamespace.equals(attr.getNodeValue()) && "xmlns".equals(attr.getPrefix())){
  1279.                         if(prefixTargetNamespaceXSD==null){
  1280.                             findIntoWSDL = (attr.getLocalName()==null);
  1281.                             break;
  1282.                         }
  1283.                         else if(prefixTargetNamespaceXSD.equals(attr.getLocalName())){
  1284.                             findIntoWSDL = true;
  1285.                             break;
  1286.                         }
  1287.                     }   
  1288.                 }
  1289.                 if(!findIntoWSDL){
  1290.                     String newPrefix = null;
  1291.                     if(prefixTargetNamespaceXSD==null){
  1292.                         //System.out.println("AGGIUNGO IN WSDL XMLNS (unique:"+uniquePrefixWSDL+"): "+targetNamespace);
  1293.                         if(uniquePrefixWSDL!=null){
  1294.                             newPrefix = "xmlns:"+uniquePrefixWSDL;
  1295.                         }
  1296.                         else{
  1297.                             newPrefix = "xmlns";
  1298.                         }
  1299.                     }else{
  1300.                         //System.out.println("AGGIUNGO IN WSDL XMLNS (unique:"+uniquePrefixWSDL+"):"+prefixTargetNamespaceXSD+" "+targetNamespace);
  1301.                         if(uniquePrefixWSDL!=null){
  1302.                             newPrefix = "xmlns:"+uniquePrefixWSDL+prefixTargetNamespaceXSD;
  1303.                         }else{
  1304.                             newPrefix = "xmlns:"+prefixTargetNamespaceXSD;
  1305.                         }
  1306.                     }
  1307.                     
  1308.                     //System.out.println("SET NEW ATTRIBUTE NS LOCALNAME["+newPrefix+"] ...");
  1309.                     schemaXSD.setAttribute(newPrefix, targetNamespace);
  1310.                     //System.out.println("SET NEW ATTRIBUTE NS LOCALNAME["+newPrefix+"] ["+targetNamespace+"] OK");
  1311.                     
  1312.                     if(prefixForWSDL.containsKey(newPrefix)==false){
  1313.                         prefixForWSDL.put(newPrefix, targetNamespace);
  1314.                     }
  1315.                     else{
  1316.                         String namespace = prefixForWSDL.get(newPrefix);
  1317.                         if(namespace.equals(targetNamespace)==false){
  1318.                             throw new org.openspcoop2.utils.wsdl.WSDLException("Rilevati due prefissi a cui sono stati associati namespace differenti. \nPrefix["+
  1319.                                     newPrefix+"]=Namespace["+namespace+"]\nPrefix["+newPrefix+"]=Namespace["+targetNamespace+"]"); 
  1320.                         }
  1321.                     }
  1322.                 }
  1323.             }
  1324.         }
  1325.         
  1326.         return targetNamespace;
  1327.     }
  1328.     
  1329.     
  1330.     
  1331.     
  1332.     
  1333.     
  1334.     
  1335.     
  1336.     
  1337.     /* ---------------- METODI REMOVE ------------------------- */
  1338.     
  1339.     /**
  1340.      * Rimuove i wsdl:import dal documento
  1341.      * 
  1342.      * @param document
  1343.      */
  1344.     public void removeImports(Document document){
  1345.         removeImport(document,null);
  1346.     }
  1347.     public void removeImport(Document document,Node importNode){
  1348.         // rimuovo eventuale import per i definitori, visto che nella versione byte[] dal db, gli import non possono essere risolti
  1349.         NodeList list = document.getChildNodes();
  1350.         if(list!=null){
  1351.             for(int i=0; i<list.getLength(); i++){
  1352.                 Node child = list.item(i);
  1353.                 if("definitions".equals(child.getLocalName())){
  1354.                     NodeList listDefinition = child.getChildNodes();
  1355.                     if(listDefinition!=null){
  1356.                         for(int j=0; j<listDefinition.getLength(); j++){
  1357.                             Node childDefinition = listDefinition.item(j);
  1358.                             if("import".equals(childDefinition.getLocalName())){
  1359.                                 if(importNode==null){
  1360.                                     //  System.out.println("REMOVE IMPORT");
  1361.                                     child.removeChild(childDefinition);
  1362.                                 }else{
  1363.                                     if(importNode.equals(childDefinition)){
  1364.                                         //System.out.println("REMOVE MIRATA");
  1365.                                         child.removeChild(childDefinition);
  1366.                                     }
  1367.                                 }
  1368.                             }
  1369.                         }
  1370.                     }
  1371.                 }
  1372.             }
  1373.         }
  1374.     }
  1375.     
  1376.     /**
  1377.      * Rimuove gli schemi dal wsdl
  1378.      * 
  1379.      * @param document
  1380.      * @throws org.openspcoop2.utils.wsdl.WSDLException
  1381.      */
  1382.     public void removeSchemiIntoTypes(Document document) throws org.openspcoop2.utils.wsdl.WSDLException{
  1383.         
  1384.         try{
  1385.             NodeList list = document.getChildNodes();
  1386.             if(list!=null){
  1387.                 for(int i=0; i<list.getLength(); i++){
  1388.                     Node child = list.item(i);
  1389.                     if("definitions".equals(child.getLocalName())){
  1390.                         NodeList listDefinition = child.getChildNodes();
  1391.                         if(listDefinition!=null){
  1392.                             for(int j=0; j<listDefinition.getLength(); j++){
  1393.                                 Node childDefinition = listDefinition.item(j);
  1394.                                 if("types".equals(childDefinition.getLocalName())){
  1395.                                     NodeList listTypes = childDefinition.getChildNodes();
  1396.                                     if(listTypes!=null){
  1397.                                         boolean onlySchemaAndComment = true;
  1398.                                         for(int h=0; h<listTypes.getLength(); h++){
  1399.                                             Node childTypes = listTypes.item(h);
  1400.                                             //System.out.println("?? IMPORT SCHEMA: "+childTypes.getLocalName());
  1401.                                             if("schema".equals(childTypes.getLocalName())){
  1402.                                                 //System.out.println("REMOVE IMPORT SCHEMA");
  1403.                                                 childDefinition.removeChild(childTypes);
  1404.                                             }
  1405.                                             else{
  1406.                                                 if( !(childTypes instanceof Text) && !(childTypes instanceof Comment) ){
  1407.                                                     onlySchemaAndComment = false;
  1408.                                                 }
  1409.                                             }
  1410.                                         }
  1411.                                         if(onlySchemaAndComment){
  1412.                                             listTypes = childDefinition.getChildNodes();
  1413.                                             if(listTypes!=null){
  1414.                                                 for(int h=0; h<listTypes.getLength(); h++){
  1415.                                                     childDefinition.removeChild(listTypes.item(h));
  1416.                                                 }
  1417.                                             }
  1418.                                         }
  1419.                                     }
  1420.                                 }
  1421.                             }
  1422.                         }
  1423.                     }
  1424.                 }
  1425.             }

  1427.         }catch(Exception e){
  1428.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  1429.         }
  1430.     }
  1431.     
  1432.     /**
  1433.      * Rimuove l'elemento types dal wsdl
  1434.      * 
  1435.      * @param wsdl
  1436.      * @throws org.openspcoop2.utils.wsdl.WSDLException
  1437.      */
  1438.     public void removeTypes(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  1439.         
  1440.         try{
  1441.             NodeList list = wsdl.getChildNodes();
  1442.             if(list!=null){
  1443.                 for(int i=0; i<list.getLength(); i++){
  1444.                     Node child = list.item(i);
  1445.                     if("definitions".equals(child.getLocalName())){
  1446.                         NodeList listDefinition = child.getChildNodes();
  1447.                         if(listDefinition!=null){
  1448.                             for(int j=0; j<listDefinition.getLength(); j++){
  1449.                                 Node childDefinition = listDefinition.item(j);
  1450.                                 if("types".equals(childDefinition.getLocalName())){
  1451.                                     //System.out.println("REMOVE TYPES");
  1452.                                     child.removeChild(childDefinition);
  1453.                                 }
  1454.                             }
  1455.                         }
  1456.                     }
  1457.                 }
  1458.             }
  1459.         }catch(Exception e){
  1460.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la rimozione dell'elemento Types: "+e.getMessage(),e);
  1461.         }
  1462.     }
  1463.     
  1464.     public void removeImportsFromSchemaXSD(Schema xsd) throws org.openspcoop2.utils.wsdl.WSDLException{
  1465.         if(this.xmlUtils==null){
  1466.             throw new org.openspcoop2.utils.wsdl.WSDLException("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  1467.         }
  1468.         XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  1469.         xsdUtils.removeImports(xsd.getElement());
  1470.     }
  1471.     public void removeIncludesFromSchemaXSD(Schema xsd) throws org.openspcoop2.utils.wsdl.WSDLException{
  1472.         if(this.xmlUtils==null){
  1473.             throw new org.openspcoop2.utils.wsdl.WSDLException("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  1474.         }
  1475.         XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  1476.         xsdUtils.removeIncludes(xsd.getElement());
  1477.     }
  1478.     public void removeImportsAndIncludesFromSchemaXSD(Schema xsd) throws org.openspcoop2.utils.wsdl.WSDLException{
  1479.         if(this.xmlUtils==null){
  1480.             throw new org.openspcoop2.utils.wsdl.WSDLException("XMLUtils not initialized in WSDLUtilities, use static instance 'getInstance(AbstractXMLUtils xmlUtils)'");
  1481.         }
  1482.         XSDUtils xsdUtils = new XSDUtils(this.xmlUtils);
  1483.         xsdUtils.removeImportsAndIncludes(xsd.getElement());
  1484.     }
  1485.     
  1486.     /**
  1487.      * Rimuove TUTTI gli Import da una definizione.
  1488.      * @param definition La definizione da modificare.
  1489.      */
  1490.     public void removeAllImports(Definition definition) throws WSDLException{
  1491.         if (definition != null) {
  1492.             DefinitionWrapper wsdl = new DefinitionWrapper(definition,this.xmlUtils);
  1493.             wsdl.removeAllImports();
  1494.         }else{
  1495.             throw new WSDLException("removeAllImports(Definition definition)","WSDL non fornito");
  1496.         }
  1497.     }
  1498.     
  1499.     /**
  1500.      * Rimuove TUTTI i messaggi da una definizione.
  1501.      * @param definition La definizione da modificare.
  1502.      */
  1503.     public void removeAllMessages(Definition definition) throws WSDLException{
  1504.         if (definition != null) {
  1505.             DefinitionWrapper wsdl = new DefinitionWrapper(definition,this.xmlUtils);
  1506.             wsdl.removeAllMessages();
  1507.         }else{
  1508.             throw new WSDLException("removeAllMessages(Definition definition)","WSDL non fornito");
  1509.         }
  1510.     }
  1511.     
  1512.     /**
  1513.      * Rimuove TUTTI i PortType da una definizione.
  1514.      * @param definition La definizione da modificare.
  1515.      */
  1516.     public void removeAllPortTypes(Definition definition) throws WSDLException{
  1517.         if (definition != null) {
  1518.             DefinitionWrapper wsdl = new DefinitionWrapper(definition,this.xmlUtils);
  1519.             wsdl.removeAllPortTypes();
  1520.         }else{
  1521.             throw new WSDLException("removeAllPortTypes(Definition definition)","WSDL non fornito");
  1522.         }
  1523.     }

  1525.     /**
  1526.      * Rimuove TUTTI i Binding da una definizione.
  1527.      * @param definition La definizione da modificare.
  1528.      */
  1529.     public void removeAllBindings(Definition definition) throws WSDLException{
  1530.         if (definition != null) {
  1531.             DefinitionWrapper wsdl = new DefinitionWrapper(definition,this.xmlUtils);
  1532.             wsdl.removeAllBindings();
  1533.         }else{
  1534.             throw new WSDLException("removeAllBindings(Definition definition)","WSDL non fornito");
  1535.         }
  1536.     }
  1537.     
  1538.     /**
  1539.      * Rimuove TUTTI i Service da una definizione.
  1540.      * @param definition La definizione da modificare.
  1541.      */
  1542.     public void removeAllServices(Definition definition) throws WSDLException{
  1543.         if (definition != null) {
  1544.             DefinitionWrapper wsdl = new DefinitionWrapper(definition,this.xmlUtils);
  1545.             wsdl.removeAllServices();
  1546.         }else{
  1547.             throw new WSDLException("removeAllServices(Definition definition)","WSDL non fornito");
  1548.         }
  1549.     }
  1550.     
  1551.     
  1552.     
  1553.     
  1554.     
  1555.     
  1556.     
  1557.     
  1558.     
  1559.     
  1560.     
  1561.     
  1562.     
  1563.     
  1564.     /* ---------------- TYPES ------------------------- */

  1566.     public boolean existsTypes(Document document) throws org.openspcoop2.utils.wsdl.WSDLException{
  1567.         
  1568.         try{
  1569.             NodeList list = document.getChildNodes();
  1570.             if(list!=null){
  1571.                 for(int i=0; i<list.getLength(); i++){
  1572.                     Node child = list.item(i);
  1573.                     if("definitions".equals(child.getLocalName())){
  1574.                         NodeList listDefinition = child.getChildNodes();
  1575.                         if(listDefinition!=null){
  1576.                             for(int j=0; j<listDefinition.getLength(); j++){
  1577.                                 Node childDefinition = listDefinition.item(j);
  1578.                                 if("types".equals(childDefinition.getLocalName())){
  1579.                                     return true;
  1580.                                 }
  1581.                             }
  1582.                         }
  1583.                     }
  1584.                 }
  1585.             }

  1587.         }catch(Exception e){
  1588.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  1589.         }
  1590.         
  1591.         return false;
  1592.     }
  1593.     
  1594.     public Node getIfExistsTypesElementIntoWSDL(Document wsdl) throws org.openspcoop2.utils.wsdl.WSDLException{
  1595.         
  1596.         try{
  1597.             NodeList list = wsdl.getChildNodes();
  1598.             if(list!=null){
  1599.                 for(int i=0; i<list.getLength(); i++){
  1600.                     Node child = list.item(i);
  1601.                     if("definitions".equals(child.getLocalName())){
  1602.                         NodeList listDefinition = child.getChildNodes();
  1603.                         if(listDefinition!=null){
  1604.                             for(int j=0; j<listDefinition.getLength(); j++){
  1605.                                 Node childDefinition = listDefinition.item(j);
  1606.                                 if("types".equals(childDefinition.getLocalName())){
  1607.                                     return childDefinition;
  1608.                                 }
  1609.                             }
  1610.                         }
  1611.                     }
  1612.                 }
  1613.             }
  1614.             return null;
  1615.         }catch(Exception e){
  1616.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  1617.         }
  1618.     }
  1619.     
  1620.     public Node addEmptyTypesIfNotExists(Document document) throws org.openspcoop2.utils.wsdl.WSDLException{
  1621.         
  1622.         try{
  1623.             boolean exists = false;
  1624.             NodeList list = document.getChildNodes();
  1625.             if(list!=null){
  1626.                 for(int i=0; i<list.getLength(); i++){
  1627.                     Node child = list.item(i);
  1628.                     if("definitions".equals(child.getLocalName())){
  1629.                         NodeList listDefinition = child.getChildNodes();
  1630.                         if(listDefinition!=null){
  1631.                             for(int j=0; j<listDefinition.getLength(); j++){
  1632.                                 Node childDefinition = listDefinition.item(j);
  1633.                                 if("types".equals(childDefinition.getLocalName())){
  1634.                                     exists = true;
  1635.                                     break;
  1636.                                 }
  1637.                             }
  1638.                         }
  1639.                         if(!exists){
  1640.                             String name = "types";
  1641.                             if(child.getPrefix()!=null && !"".equals(child.getPrefix())){
  1642.                                 name = child.getPrefix()+":"+name;
  1643.                             }
  1644.                             Node n = this.xmlUtils.getFirstNotEmptyChildNode(child,false);
  1645.                             //System.out.println("FIRST ["+n.getLocalName()+"] ["+n.getPrefix()+"] ["+n.getNamespaceURI()+"]");
  1646.                             Node type = document.createElementNS(child.getNamespaceURI(), name);
  1647.                             child.insertBefore(type,n);
  1648.                             return type;
  1649.                         }
  1650.                     }
  1651.                 }
  1652.             }

  1654.             return null;
  1655.             
  1656.         }catch(Exception e){
  1657.             throw new org.openspcoop2.utils.wsdl.WSDLException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  1658.         }
  1659.     }
  1660. }
Created with JaCoCo 0.8.8.202204050719