private Document wsdl;

private Document ssd; //Simple Service Definition

private String vbCrLf = "\r\n";

private String ElementNameSpace = "";

private java.util.HashMap<String, String> NameSpaces;

private NodeList Schema;

private String HttpProxyServer;

private class Port{

public String Name;

public String Binding;

public String Address;

}

private class Binding{

public String Operation;

public String SoapAction;

public String Style;

public String Name;

public String Type;

}

private class Message{ //PortType

public String Input;

public String Output;

public String Documentation = null;

}

private class Element{

private int id;

public String Name;

public String Type;

public boolean IsNillable = false;

public boolean IsComplex = false;

public String minOccurs = "0";

public String maxOccurs = "1";

public boolean IsAttribute = false;

public String tagName = "parameter";

private java.util.ArrayList<Object> children = new java.util.ArrayList<>();

public int hashCode(){

return id;

}

public boolean equals(Object obj){

if (obj instanceof Element){

return id==((Element) obj).id;

}

else if (obj instanceof Node){

return id==new Element((Node) obj).id;

}

return false;

}

public Element(String Name, String Type){

id = (Name + "\t" + Type).hashCode();

this.Name = Name;

this.Type = stripNameSpace(Type);

IsComplex = isElementComplex(Type);

}

public Element(Node node){

String nodeName = stripNameSpace(node.getNodeName());

NamedNodeMap attr = node.getAttributes();

Name = DOM.getAttributeValue(attr, "name");

Type = DOM.getAttributeValue(attr, "type");

id = (Name + "\t" + Type).hashCode();

IsNillable = isElementNillable(DOM.getAttributeValue(attr, "nillable"));

IsComplex = isElementComplex(Type);

minOccurs = DOM.getAttributeValue(attr, "minOccurs");

maxOccurs = DOM.getAttributeValue(attr, "maxOccurs");

if (minOccurs.length()==0) minOccurs = "0";

if (maxOccurs.length()==0) maxOccurs = "1";

Type = stripNameSpace(Type);

String elementRef = DOM.getAttributeValue(attr, "ref");

if (elementRef.length()>0){

Name = elementRef;

}

if (nodeName.equalsIgnoreCase("attribute")){

IsAttribute = true;

IsNillable = DOM.getAttributeValue(attr, "use").equalsIgnoreCase("optional");

}

}

public void addElement(Element element){

//Child elements should be unique.

boolean addElement = true;

java.util.Iterator it = children.iterator();

while (it.hasNext()){

Object child = it.next();

if (child instanceof Element){

Element e = (Element) child;

if (e.Name.equals(element.Name) && e.Type.equals(element.Type)){

addElement = false;

}

}

}

if (addElement) children.add(element);

}

public void addChoices(Choices choices){

children.add(choices);

}

public void addOptions(Options options){

children.add(options);

}

public String toString(){

StringBuffer xml = new StringBuffer();

xml.append(" <" + tagName + " " +

"name=\"" + Name + "\" " +

"type=\"" + Type + "\" " +

"minOccurs=\"" + minOccurs + "\" " +

"maxOccurs=\"" + maxOccurs + "\" " +

"isattribute=\"" + IsAttribute + "\" " +

"iscomplex=\"" + IsComplex + "\" " +

"isnillable=\"" + IsNillable + "\">" + vbCrLf);

java.util.Iterator it = children.iterator();

while (it.hasNext()){

xml.append(it.next().toString());

}

xml.append(" </" + tagName + ">" + vbCrLf);

return xml.toString();

}

}

private class Options{

private java.util.ArrayList<String> options = new java.util.ArrayList<>();

public Options(){}

public void addOption(String option){

options.add(option);

}

public String toString(){

StringBuffer xml = new StringBuffer();

if (!options.isEmpty()){

xml.append(" <options>");

xml.append(vbCrLf);

java.util.Iterator<String> it = options.iterator();

while (it.hasNext()){

String option = it.next();

xml.append(" <option value=\"" + option + "\">" + option + "</option>" + vbCrLf);

}

xml.append(" </options>");

xml.append(vbCrLf);

}

return xml.toString();

}

}

private class Choices{

private java.util.ArrayList<Element> choices = new java.util.ArrayList<>();

public Choices(){}

public void addChoice(Element choice){

choices.add(choice);

}

public String toString(){

StringBuffer xml = new StringBuffer();

if (!choices.isEmpty()){

xml.append(" <options>");

xml.append(vbCrLf);

java.util.Iterator<Element> it = choices.iterator();

while (it.hasNext()){

xml.append(" ");

xml.append("<option>");

xml.append(it.next().toString());

xml.append("</option>");

xml.append(vbCrLf);

}

xml.append(" </options>");

xml.append(vbCrLf);

}

return xml.toString();

}

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Instantiate wsdl parser using a url to a wsdl (java.net.url)

public WSDL(java.net.URL url){

this(downloadXML(url, null), null, true, null);

}

public WSDL(String url){

this(downloadXML(url, null), null, true, null);

}

public WSDL(java.net.URL url, String HttpProxyServer){

this(downloadXML(url, HttpProxyServer), null, true, HttpProxyServer);

}

public WSDL(Document wsdl) {

this(wsdl, null, true, null);

}

public WSDL(Document wsdl, String HttpProxyServer) {

this(wsdl, null, true, HttpProxyServer);

}

public WSDL(Document wsdl, Document[] xsd) {

this(wsdl, xsd, false, null);

}

private WSDL(Document wsdl, Document[] xsd, boolean followImports, String HttpProxyServer) {

this.wsdl = wsdl;

NameSpaces = DOM.getNameSpaces(wsdl);

ElementNameSpace = getElementNameSpace();

if (xsd==null){

xsd = new Document[1];

xsd[0] = wsdl;

}

else{

Document[] arr = new Document[xsd.length+1];

arr[0] = wsdl;

for (int i=1; i<arr.length; i++){

arr[i] = xsd[i-1];

}

xsd = arr;

}

this.HttpProxyServer = HttpProxyServer;

addSchema(xsd, followImports, false);

parseWSDL();

}

//**************************************************************************

//** getSSD

//**************************************************************************

/** Returns a Simple Service Description (SSD) - an xml document which

public Document getSSD(){

return ssd;

}

//**************************************************************************

//** toString

//**************************************************************************

/** Returns a string representing an XML document containing a Simple

public String toString(){

return DOM.getText(ssd);

}

private NamedNodeMap getDefinitionAttributes(){

NodeList Definitions = wsdl.getChildNodes();

for (int i=0; i<Definitions.getLength(); i++ ) {

if (Definitions.item(i).getNodeType() == 1){

if (contains(Definitions.item(i).getNodeName(), "definitions")) {

return Definitions.item(i).getAttributes();

}

}

}

return null;

}

//**************************************************************************

//** getTargetNameSpace

//**************************************************************************

private String getTargetNameSpace(){

NamedNodeMap attr = getDefinitionAttributes();

return DOM.getAttributeValue(attr, "targetNamespace");

}

//**************************************************************************

//** getElementNameSpace

//**************************************************************************

private String getElementNameSpace(){

String elementNameSpace = "http://www.w3.org/2001/XMLSchema";

NamedNodeMap attr = getDefinitionAttributes();

if (attr!=null){

Node node;

String nodeName;

String nodeValue;

for (int i=0; i < attr.getLength(); i++ ) {

node = attr.item(i);

nodeName = node.getNodeName().toLowerCase();

nodeValue = node.getNodeValue();

if (nodeValue.toLowerCase().equals(elementNameSpace.toLowerCase())) {

return stripNameSpace(nodeName);

}

}

}

return "";

}

//**************************************************************************

//** isElementComplex

//**************************************************************************

private boolean isElementComplex(String elementType){

String elementNameSpace = "";

if (elementType.contains(":")){

elementNameSpace = elementType.substring(0, elementType.indexOf(":"));

}

return !elementNameSpace.equalsIgnoreCase(ElementNameSpace);

}

//**************************************************************************

//** isElementNillable

//**************************************************************************

private boolean isElementNillable(String isnillable){

if (isnillable.toLowerCase().equals("true")){

return true;

}

else{

return false;

}

}

//**************************************************************************

//** parseWSDL

//**************************************************************************

/** Used to parse the WSDL and generate the SSD.

private void parseWSDL(){

String SSD = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + vbCrLf +

"<ssd>" + vbCrLf;

String ServiceName = "";

String ServiceDescription = "";

NodeList Definitions, ChildNodes;

NamedNodeMap attr;

Port Port = null;

Binding Binding = null;

java.util.ArrayList<Binding> arrBindings = null;

Element Element = null;

java.util.ArrayList<Element> arrElements = null;

//Loop Through Definitions and Get Services

//definitions->service (name attribute)

Definitions = getDefinitions();

for (int i=0; i<Definitions.getLength(); i++ ) {

if (contains(Definitions.item(i).getNodeName(), "service")) {

//Get Service Name

attr = Definitions.item(i).getAttributes();

ServiceName = DOM.getAttributeValue(attr, "name");

//Get Service Description

ChildNodes = Definitions.item(i).getChildNodes();

for (int j=0; j<ChildNodes.getLength(); j++ ) {

if (contains(ChildNodes.item(j).getNodeName(), "documentation")) {

ServiceDescription = ChildNodes.item(j).getTextContent();

}

}

//Get Service Port

Port = getPort(ChildNodes);

if (Port!=null){

SSD += " <service name=\"" + ServiceName + "\" url=\"" + Port.Address + "\" namespace=\"" + getTargetNameSpace() + "\">" + vbCrLf;

if (ServiceDescription!=null){

SSD += " <description>" + ServiceDescription + "</description>" + vbCrLf;}

SSD += " <methods>" + vbCrLf;

//Get Bindings

arrBindings = getBindings(Port.Binding);

for (int j=0; j<arrBindings.size(); j++ ) {

Binding = arrBindings.get(j);

//Get Soap Action

String SoapAction = Binding.SoapAction;

if (SoapAction!=null) SoapAction = " soapAction=\"" + SoapAction + "\"";

//Get Messages (need to valid logic here!)

//Message Message = getMessages(Port.Name,Binding.Operation);

//if (Message==null) Message = getMessages(Port.Binding,Binding.Operation);

Message Message = getMessages(Binding.Type,Binding.Operation);

//Get Response Element

String ResultsNode = "";

try{

arrElements = getElements(Message.Output);

for (int k=0; k<arrBindings.size(); k++ ) {

Element = arrElements.get(k);

ResultsNode = Element.Name;

}

}

catch(Exception e){

//System.out.println(e.toString());

}

SSD +=" <method name=\"" + Binding.Operation + "\"" + SoapAction + " resultsNode=\"" + ResultsNode + "\">" + vbCrLf;

if (Message.Documentation!=null){

SSD += " <description>" + Message.Documentation + "</description>" + vbCrLf;

}

SSD += " <parameters>" + vbCrLf;

arrElements = getElements(Message.Input);

try{

for (int k=0; k<arrElements.size(); k++ ) {

Element = arrElements.get(k);

SSD += Element.toString();

}

}

catch(Exception e){

//System.out.println(e.toString());

}

SSD += " </parameters>" + vbCrLf;

SSD += " <outputs>" + vbCrLf;

arrElements = getElements(Message.Output);

try{

for (int k=0; k<arrElements.size(); k++ ) {

Element = arrElements.get(k);

Element.tagName = "output";

SSD += Element.toString();

}

}

catch(Exception e){

//System.out.println(e.toString());

}

SSD += " </outputs>" + vbCrLf;

SSD +=" </method>" + vbCrLf;

}

//Update SSD

SSD += " </methods>" + vbCrLf;

SSD += " </service>" + vbCrLf;

}

}

}

SSD += vbCrLf + "</ssd>";

//System.out.println(SSD);

ssd = DOM.createDocument(SSD);

knownTypes.clear();

}

//**************************************************************************

//** getPort

//**************************************************************************

private Port getPort(NodeList Ports){

Port Port = null;

String PortName, PortBinding, PortAddress;

boolean foundSoapPort = false;

for (int j=0; j<Ports.getLength(); j++ ) {

if (contains(Ports.item(j).getNodeName(), "port")) {

//Get Service Binding

NamedNodeMap attr = Ports.item(j).getAttributes();

PortName = DOM.getAttributeValue(attr, "name");

PortBinding = stripNameSpace(DOM.getAttributeValue(attr, "binding"));

//Get Service Endpoint (url)

PortAddress = "";

NodeList Addresses = Ports.item(j).getChildNodes();

for (int k=0; k<Addresses.getLength(); k++ ) {

String Address = Addresses.item(k).getNodeName();

//System.out.println(Address);

if (contains(Address, "address") && //soap:address

!contains(Address,"http:") &&

!contains(Address,"https:") && //untested prefix

!contains(Address,"soap12:") //untested prefix (suggested by user)

){

attr = Addresses.item(k).getAttributes();

PortAddress = DOM.getAttributeValue(attr, "location");

foundSoapPort = true;

}

}

if (foundSoapPort){

Port = new Port();

Port.Name = PortName;

Port.Binding = PortBinding;

Port.Address = PortAddress;

return Port;

}

}

}

return Port;

}

//**************************************************************************

//** getBindings

//**************************************************************************

private java.util.ArrayList<Binding> getBindings(String PortBinding){

NodeList Definitions, ChildNodes;

NamedNodeMap attr;

String BindingName, BindingType, BindingStyle, BindingTransport;

Binding Binding = null;

java.util.ArrayList<Binding> arrBindings = null;

int BindingCount = -1;

//Loop through definitions

Definitions = getDefinitions();

//Definitions = Definitions.item(0).getChildNodes();

for (int i=0; i<Definitions.getLength(); i++ ) {

if (contains(Definitions.item(i).getNodeName(), "binding")) {

//Get Binding Name

attr = Definitions.item(i).getAttributes();

BindingName = DOM.getAttributeValue(attr, "name");

BindingType = DOM.getAttributeValue(attr, "type");

if (BindingName.equals(PortBinding)){

arrBindings = new java.util.ArrayList<>();

//Get Binding Transport/Style

BindingStyle = BindingTransport = "";

ChildNodes = Definitions.item(i).getChildNodes();

for (int j=0; j<ChildNodes.getLength(); j++ ) {

if (contains(ChildNodes.item(j).getNodeName(), "binding")) {

attr = ChildNodes.item(j).getAttributes();

BindingStyle = DOM.getAttributeValue(attr, "style");

BindingTransport = DOM.getAttributeValue(attr, "transport");

}

}

//Get Operation Names/Soap Action

for (int j=0; j<ChildNodes.getLength(); j++ ) {

if (contains(ChildNodes.item(j).getNodeName(), "operation")) {

Binding = new Binding();

BindingCount +=1;

attr = ChildNodes.item(j).getAttributes();

Binding.Operation = DOM.getAttributeValue(attr, "name");

NodeList Operations = ChildNodes.item(j).getChildNodes();

for (int k=0; k<Operations.getLength(); k++ ) {

if (contains(Operations.item(k).getNodeName(), "operation")) {

attr = Operations.item(k).getAttributes();

Binding.SoapAction = DOM.getAttributeValue(attr, "soapaction");

Binding.Style = BindingStyle; //DOM.getAttributeValue(attr, "style");

Binding.Name = BindingName;

Binding.Type = stripNameSpace(BindingType);

}

}

arrBindings.add(Binding);

}

}

return arrBindings;

}

}

}

return null;

}

//**************************************************************************

//** getMessages

//**************************************************************************

private Message getMessages(String PortTypeName, String OperationName){

//System.out.println();

//System.out.println(PortTypeName);

NodeList Definitions, PortTypes, Messages;

NamedNodeMap attr;

String portTypeName, operationName, messageName;

Message Message = null;

//Loop through definitions

Definitions = getDefinitions();

//Definitions = Definitions.item(0).getChildNodes();

for (int i=0; i<Definitions.getLength(); i++ ) {

if (contains(Definitions.item(i).getNodeName(), "porttype")) {

attr = Definitions.item(i).getAttributes();

portTypeName = DOM.getAttributeValue(attr, "name");

//System.out.println(" vs " + DOM.getAttributeValue(attr, "name"));

if (portTypeName.equals(PortTypeName)){

String Documentation = "";

//Loop through PortTypes

PortTypes = Definitions.item(i).getChildNodes();

for (int j=0; j<PortTypes.getLength(); j++ ) {

String NodeName = PortTypes.item(j).getNodeName();

if (NodeName.endsWith("documentation")) {

Documentation = DOM.getNodeValue(PortTypes.item(j));

}

if (NodeName.endsWith("operation")) {

attr = PortTypes.item(j).getAttributes();

operationName = DOM.getAttributeValue(attr, "name");

if (operationName.equals(OperationName)){

//Instantiate Message Object

Message = new Message();

Message.Documentation = Documentation;

//Loop through the Messages

Messages = PortTypes.item(j).getChildNodes();

for (int k=0; k<Messages.getLength(); k++ ) {

if (Messages.item(k).getNodeType()==1){

attr = Messages.item(k).getAttributes();

messageName = stripNameSpace(DOM.getAttributeValue(attr, "message"));

if (contains(Messages.item(k).getNodeName(), "input")) {

Message.Input = messageName;

}

if (contains(Messages.item(k).getNodeName(), "output")) {

Message.Output = messageName;

}

if (contains(Messages.item(k).getNodeName(), "documentation")) {

Documentation = DOM.getNodeValue(Messages.item(k));

if (Documentation.length()>0){

Message.Documentation = Documentation;

}

}

}

}

return Message;

}

}

}

}

}

}

return Message;

}

//**************************************************************************

//** getElements

//**************************************************************************

/** Returns a list of elements (parameters) associated with a given message.

private java.util.ArrayList<Element> getElements(String MessageName){

NodeList Definitions, Messages;

NamedNodeMap attr;

String messageName, name, type, min, max;

java.util.ArrayList<Element> elements = new java.util.ArrayList<>();

//Loop through Definitions and Find Messages

Definitions = getDefinitions();

for (int i=0; i<Definitions.getLength(); i++ ) {

if (contains(Definitions.item(i).getNodeName(), "message")) {

attr = Definitions.item(i).getAttributes();

messageName = DOM.getAttributeValue(attr, "name");

if (messageName.equals(MessageName)){

//Loop through Messages and Find Message Parts

Messages = Definitions.item(i).getChildNodes();

for (int j=0; j<Messages.getLength(); j++ ) {

if (contains(Messages.item(j).getNodeName(), "part")) {

attr = Messages.item(j).getAttributes();

type = DOM.getAttributeValue(attr, "type");

String element = stripNameSpace(DOM.getAttributeValue(attr, "element"));

elements = getElement(element);

}

}

return elements;

}

}

}

return null;

}

//**************************************************************************

//** getDefinitions

//**************************************************************************

private NodeList getDefinitions(){

NodeList Definitions = wsdl.getChildNodes();

if (Definitions!=null){

for (int i=0; i<Definitions.getLength(); i++){

Node node = Definitions.item(i);

if (node.getNodeType() == 1){

if (node.getNodeName().endsWith("definitions")) {

return Definitions.item(i).getChildNodes();

}

}

}

}

return null;

}

//**************************************************************************

//** getTypes

//**************************************************************************

private NodeList getTypes(){

NodeList Definitions = getDefinitions();

if (Definitions!=null){

for (int i=0; i<Definitions.getLength(); i++ ) {

Node node = Definitions.item(i);

if (node.getNodeType()==1){

if (node.getNodeName().endsWith("types")){

return node.getChildNodes();

}

}

}

}

return null;

}

//**************************************************************************

//** getShema

//**************************************************************************

private NodeList getSchema(){

return Schema;

}

//**************************************************************************

//** addSchema

//**************************************************************************

/** Used to add an external XSD.

public void addSchema(Document xsd, boolean followImports){

addSchema(new Document[]{xsd}, followImports);

}

//**************************************************************************

//** addSchemas

//**************************************************************************

/** Used to add multiple external XSDs.

public void addSchema(Document[] xsd, boolean followImports){

this.addSchema(xsd, followImports, true);

}

private void addSchema(Document[] XSDs, boolean followImports, boolean parseWSDL){

if (XSDs==null) return;

if (XSDs.length==0) return;

//Create xml document to store all the schema

StringBuffer xml = new StringBuffer();

xml.append("<?xml version=\"1.0\"?>");

xml.append("<schemas");

java.util.Iterator<String> it = NameSpaces.keySet().iterator();

while (it.hasNext()){

String ns = it.next();

String url = (String) NameSpaces.get(ns);

xml.append(" xmlns:");

xml.append(ns);

xml.append("=\"");

xml.append(url);

xml.append("\"");

}

xml.append(">");

//Add existing schema

if (this.Schema!=null) xml.append(DOM.getText(this.Schema));

//Loop through the new schemas

for (Document xsd : XSDs){

if (xsd!=null){

Node outerNode = DOM.getOuterNode(xsd);

String outerNodeName = stripNameSpace(outerNode.getNodeName());

java.util.ArrayList<Node> schemaNodes = new java.util.ArrayList<Node>();

if (outerNodeName.equalsIgnoreCase("definitions")){

NodeList childNodes = outerNode.getChildNodes();

for (int i=0; i<childNodes.getLength(); i++){

Node node = childNodes.item(i);

if (stripNameSpace(node.getNodeName()).equalsIgnoreCase("types")){

NodeList types = node.getChildNodes();

for (int j=0; j<types.getLength(); j++){

Node typeNode = types.item(j);

if (stripNameSpace(typeNode.getNodeName()).equalsIgnoreCase("schema")){

NodeList nodes = typeNode.getChildNodes();

for (int k=0; k<nodes.getLength(); k++ ) {

schemaNodes.add(nodes.item(k));

}

}

}

}

}

}

else if (outerNodeName.equalsIgnoreCase("schema")){

//schemaNodes = outerNode.getChildNodes();

NodeList nodes = outerNode.getChildNodes();

for (int k=0; k<nodes.getLength(); k++ ) {

schemaNodes.add(nodes.item(k));

}

}

else{

return;

}

NameSpaces.putAll(DOM.getNameSpaces(xsd));

StringBuffer auxSchemas = new StringBuffer();

//Loop through Schemas and Get Imports

for (int i=0; i<schemaNodes.size(); i++ ) {

Node schemaNode = schemaNodes.get(i);

Node importNode = getNode(schemaNode, "import");

if (importNode!=null){

if (followImports){

NamedNodeMap attr = importNode.getAttributes();

String schemaLocation = DOM.getAttributeValue(attr, "schemaLocation");

if (schemaLocation.length()>0){

importSchemas(schemaLocation, auxSchemas, HttpProxyServer);

}

}

Node iSchema = importNode.getParentNode();

iSchema.removeChild(importNode);

}

}

//Insert new schemas

for (int i=0; i<schemaNodes.size(); i++ ) {

Node schemaNode = schemaNodes.get(i);

xml.append(DOM.getText(schemaNode));

}

//xml.append(DOM.getText(schemaNodes));

xml.append(auxSchemas);

}

}

//Finish writing the xml document, serialize it to a DOM object, and reparse the WSDL

xml.append("</schemas>");

//boolean parseWSDL = this.Schema!=null;

this.Schema = DOM.getOuterNode(DOM.createDocument(xml.toString())).getChildNodes();

if (parseWSDL) parseWSDL();

}

//**************************************************************************

//** importSchemas

//**************************************************************************

/** Used to download and parse an XSD document. Used in conjunction with the