private static void CollectIncludes(XmlSchema schema, Hashtable includeSchemas)
{
XmlSchemaObjectEnumerator enumerator = schema.Includes.GetEnumerator();
while (enumerator.MoveNext())
{
var current = (XmlSchemaExternal)enumerator.Current;
string schemaLocation = current.SchemaLocation;
if (current is XmlSchemaImport)
{
current.SchemaLocation = null;
}
else if (((current is XmlSchemaInclude) && (schemaLocation != null)) && (schemaLocation.Length > 0))
{
string str2 = Path.GetFullPath(schemaLocation).ToLower();
if (includeSchemas[str2] == null)
{
XmlSchema schema2 = ReadSchema(schemaLocation);
includeSchemas[str2] = schema2;
CollectIncludes(schema2, includeSchemas);
}
current.Schema = (XmlSchema)includeSchemas[str2];
current.SchemaLocation = null;
}
}
}
private static void TraverseParticle(XmlSchemaParticle particle, ArrayList elementDeclsInContentModel)
{
if (particle is XmlSchemaElement)
{
XmlSchemaElement value = particle as XmlSchemaElement;
elementDeclsInContentModel.Add(value);
}
else if (particle is XmlSchemaGroupBase)
{
XmlSchemaGroupBase xmlSchemaGroupBase = particle as XmlSchemaGroupBase;
XmlSchemaObjectEnumerator enumerator = xmlSchemaGroupBase.Items.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlSchemaParticle particle2 = (XmlSchemaParticle)enumerator.Current;
RDLValidatingReader.TraverseParticle(particle2, elementDeclsInContentModel);
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
else if (particle is XmlSchemaAny)
{
XmlSchemaAny xmlSchemaAny = particle as XmlSchemaAny;
RDLValidatingReader.m_processContent = xmlSchemaAny.ProcessContents;
}
}
private TypeMapping ImportDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, bool isList)
{
TypeMapping mapping = this.ImportNonXsdPrimitiveDataType(dataType, typeNs);
if (mapping != null)
{
return(mapping);
}
if (dataType.Content is XmlSchemaSimpleTypeRestriction)
{
XmlSchemaSimpleTypeRestriction content = (XmlSchemaSimpleTypeRestriction)dataType.Content;
using (XmlSchemaObjectEnumerator enumerator = content.Facets.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (enumerator.Current is XmlSchemaEnumerationFacet)
{
return(this.ImportEnumeratedDataType(dataType, typeNs, identifier, isList));
}
}
goto Label_0104;
}
}
if ((dataType.Content is XmlSchemaSimpleTypeList) || (dataType.Content is XmlSchemaSimpleTypeUnion))
{
if (dataType.Content is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)dataType.Content;
if (list.ItemType != null)
{
mapping = this.ImportDataType(list.ItemType, typeNs, identifier, true);
if (mapping != null)
{
return(mapping);
}
}
}
return(new PrimitiveMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(string)), TypeName = mapping.TypeDesc.DataType.Name
});
}
Label_0104:
return(this.ImportPrimitiveDataType(dataType));
}
private static void CheckTypes(ServiceDescription description, BasicProfileViolationCollection violations)
{
foreach (XmlSchema schema in description.Types.Schemas)
{
if ((schema.TargetNamespace == null) || (schema.TargetNamespace.Length == 0))
{
using (XmlSchemaObjectEnumerator enumerator2 = schema.Items.GetEnumerator())
{
while (enumerator2.MoveNext())
{
if (!(enumerator2.Current is XmlSchemaAnnotation))
{
violations.Add("R2105", System.Web.Services.Res.GetString("Element", new object[] { "schema", description.TargetNamespace }));
break;
}
}
}
}
}
}
public ItemEnumerator(DataModelSchema schema, XmlSchemaObjectEnumerator xmlSchemaObjectEnumerator)
{
// Initialize the object
this.schema = schema;
this.xmlSchemaObjectEnumerator = xmlSchemaObjectEnumerator;
}
private void button1_Click(object sender, EventArgs e)
{
Logger.Text = "";
XmlTextReader xmlr = null;
System.Web.Services.Description.ServiceDescription servdesc = null;
System.Web.Services.Description.PortTypeCollection ports = null;
System.Web.Services.Description.OperationCollection ops = null;
System.Xml.Serialization.XmlSchemas schemas = null;
for (int i = 0; i < httpheaderlist.Items.Count; i++)
{
httpheaderlist.Items.RemoveAt(i);
}
if (!urltext.Text.StartsWith("http"))
{
MessageBox.Show("Please enter a URL starting with http");
return;
}
if (urltext.Text.IndexOf("://") == -1)
{
MessageBox.Show("Did you forget the protocol like http:// or https:// ?" +
"\r\n E.g., http://soap.amazon.com/schemas2/AmazonWebServices.wsdl");
return;
}
try
{
xmlr = new XmlTextReader(urltext.Text);
xmlr.WhitespaceHandling = WhitespaceHandling.None;
servdesc = System.Web.Services.Description.ServiceDescription.Read(xmlr);
schemas = servdesc.Types.Schemas;
Logger.Text += "=== Found " + schemas.Count + " schema(s)===\r\n";
for (int k = 0; k < schemas.Count; k++)
{
XmlSchemaObjectCollection xmlelem = schemas[k].Items;
XmlSchemaObjectEnumerator enumerator = xmlelem.GetEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current is XmlSchemaElement)
{
XmlSchemaElement xse = (XmlSchemaElement)enumerator.Current;
Logger.Text += xse.Name + '=' + xse.SchemaType + ", ";
TraverseParticle(xse);
}
else
{
if (enumerator.Current is XmlSchemaComplexType)
{
XmlSchemaComplexType xsct = (XmlSchemaComplexType)enumerator.Current;
Logger.Text += '\'' + xsct.Name + ": ";
TraverseParticle(xsct.Particle);
if (xsct.ContentModel is XmlSchemaSimpleContent)
{
Logger.Text += "Simple; ";
}
else
{
//XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)xsct.ContentModel;
if (xsct.ContentModel is XmlSchemaComplexContent)
{
Logger.Text += "Complex; ";
}
}
Logger.Text += "\',";
}
}
}
Logger.Text += "\r\n";
}
ports = servdesc.PortTypes;
Logger.Text += " *** Found " + ports.Count + " portType(s) *** \r\n";
TreeNode tn = null;
TreeNode msgNode = null;
TreeNode root = new TreeNode(urltext.Text);
treeView1.Nodes.Add(root);
for (int j = 0; j < ports.Count; j++)
{
ops = ports[j].Operations;
Logger.Text += " --- Found " + ops.Count + " operation(s) in : " + (j + 1) + " ---\r\n";
for (int i = 0; i < ops.Count; i++)
{
Logger.Text += ops[i].Name + "->" + "\r\n";
tn = new TreeNode(ops[i].Name);
root.Nodes.Add(tn);
System.Web.Services.Description.OperationMessageCollection iter = ops[i].Messages;
//Message msgiter = null;
for (int k = 0; k < iter.Count; k++)
{
Logger.Text += iter[k].Message.Name + "\r\n";
msgNode = new TreeNode(iter[k].Message.Name);
tn.Nodes.Add(msgNode);
}
}
}
GenerateSOAP();
/*
* while (xmlr.Read())
* {
* switch (xmlr.NodeType)
* {
* case XmlNodeType.Element:
*
* Logger.Text += xmlr.Name + "->" + xmlr.R + "\r\n";
* break;
* case XmlNodeType.EndElement:
* break;
* default:
* break;
* }
* }
*/
}
catch (XmlException xe)
{
Logger.Text += xe.StackTrace;
}
catch (Exception ex)
{
Logger.Text += ex.StackTrace;
}
finally
{
if (xmlr != null)
{
xmlr.Close();
}
}
}
