private void treeView1_AfterCheck(object sender, TreeViewEventArgs e)
{
if (e.Node.Tag != null)
{
WebFunctions webfunc = e.Node.Tag as WebFunctions;
if (webfunc != null)
{
propertyGrid1.SelectedObject = webfunc;
webfunc.Output = e.Node.Checked;
webfunc.Save();
//LoadFunctions();
}
}
}
private void GetRegisterClasses(SoapClasses soapClass, WebFunctions webfunc)
{
for (int loop = 0; loop < soapClass.Properties.Count; loop++)
{
SoapClassProperties property = soapClass.Properties[loop];
if (property.IsComplexType && !keysRegister.Contains(property.Name))
{
var complexClass = WebService.SoapClasses.Where(x => x.Name == property.PropertyClassType).FirstOrDefault();
if (complexClass != null && !complexClass.IsEnum && !keysRegister.Contains(complexClass.Name))
{
complexClass.Output = true;
complexClass.Save();
webfunc.RegisterClasses = string.Format("{0};{1}", webfunc.RegisterClasses, complexClass.Name);
webfunc.Save();
keysRegister.Add(complexClass.Name);
registerStrings.AppendLine(complexClass.RegisterText);
GetRegisterClasses(complexClass, webfunc);
}
}
}
}
public void Parse()
{
UriBuilder uriBuilder = new UriBuilder(webserv.Url);
uriBuilder.Query = "WSDL";
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uriBuilder.Uri);
webRequest.ContentType = "text/xml;charset=\"utf-8\"";
webRequest.Method = "GET";
webRequest.Accept = "text/xml";
ServiceDescription serviceDescription;
using (WebResponse response = webRequest.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
serviceDescription = ServiceDescription.Read(stream);
}
}
var oldfuncs = (from q in new XPQuery <WebFunctions>(XpoDefault.Session)
where q.Service.Oid == webserv.Oid
select q).ToList();
if (serviceDescription != null && serviceDescription.Services.Count > 0)
{
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.ProtocolName = "Soap11";
importer.AddServiceDescription(serviceDescription, null, null);
importer.Style = ServiceDescriptionImportStyle.Client;
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
Service service = serviceDescription.Services[0];
this.Namespace = serviceDescription.TargetNamespace;
this.ServiceName = service.Name;
webserv.ServiceName = service.Name;
webserv.NameSpace = serviceDescription.TargetNamespace;
webserv.UpdateDate = DateTime.Now;
for (int i = webserv.SoapClasses.Count - 1; i >= 0; i--)
{
webserv.SoapClasses[i].Delete();
}
#region Operation
List <string> operationNames = new List <string>();
//Loop through the port types in the service description and list all of the
//web service's operations and each operations input/output
PortType portType = serviceDescription.PortTypes[0];
//foreach (PortType portType in serviceDescription.PortTypes)
{
int FunctionIndex = 0;
this.Functions = new List <WebFunctions>();
foreach (Operation operation in portType.Operations)
{
WebFunctions newFunc = new WebFunctions();
newFunc.Service = webserv;
var oldfunc = oldfuncs.Where(x => x.Name == operation.Name).FirstOrDefault();
if (oldfunc != null)
{
newFunc.Output = oldfunc.Output;
}
newFunc.Name = operation.Name;
newFunc.SoapAction = this.Namespace + operation.Name;
operationNames.Add(operation.Name);
foreach (var message in operation.Messages)
{
if (message is OperationInput)
{
foreach (Message messagePart in serviceDescription.Messages)
{
if (messagePart.Name != ((OperationMessage)message).Message.Name)
{
continue;
}
foreach (MessagePart part in messagePart.Parts)
{
newFunc.InputType = part.Element.Name;
}
}
}
if (message is OperationOutput)
{
foreach (Message messagePart in serviceDescription.Messages)
{
if (messagePart.Name != ((OperationMessage)message).Message.Name)
{
continue;
}
foreach (MessagePart part in messagePart.Parts)
{
newFunc.OutputType = part.Element.Name;
}
}
}
}
newFunc.Save();
this.Functions.Add(newFunc);
FunctionIndex++;
}
} //End listing of types
for (int i = oldfuncs.Count - 1; i >= 0; i--)
{
oldfuncs[i].Delete();
}
#endregion
#region Types
Types types = serviceDescription.Types;
XmlSchema xmlSchema = types.Schemas[0];
foreach (object item in xmlSchema.Items)
{
XmlSchemaComplexType _complexType = item as System.Xml.Schema.XmlSchemaComplexType;
XmlSchemaElement schemaElement = item as XmlSchemaElement;
XmlSchemaComplexType complexType = item as XmlSchemaComplexType;
if (schemaElement != null && JavaTypeConverter.IsComplexType(schemaElement.Name))
{
SoapClasses newClass = this.GetClass(schemaElement.Name);
newClass.Name = schemaElement.Name;
newClass.Service = webserv;
newClass.Type = ClassType.Unknown;
newClass.SuperClassType = string.Empty;
newClass.Output = false;
if (_complexType != null)
{
XmlSchemaContentModel model = _complexType.ContentModel;
XmlSchemaComplexContent complex = model as XmlSchemaComplexContent;
if (complex != null)
{
XmlSchemaComplexContentExtension extension = complex.Content as XmlSchemaComplexContentExtension;
if (extension != null)
{
newClass.SuperClassType = extension.BaseTypeName.Name;
}
}
}
XmlSchemaType schemaType = schemaElement.SchemaType;
XmlSchemaComplexType schemaComplexType = schemaType as XmlSchemaComplexType;
if (schemaComplexType != null)
{
XmlSchemaParticle particle = schemaComplexType.Particle;
XmlSchemaSequence sequence = particle as XmlSchemaSequence;
if (sequence != null)
{
foreach (XmlSchemaElement childElement in sequence.Items)
{
SoapClassProperties newProp = new SoapClassProperties(XpoDefault.Session);
newProp.Name = childElement.Name;
newProp.PropertyClassType = childElement.SchemaTypeName.Name;
newProp.IsArray = childElement.SchemaTypeName.Name.StartsWith("ArrayOf");
newClass.Properties.Add(newProp);
}
}
}
newClass.Save();
//this.ComplexTypes.Add(newClass);
}
else if (complexType != null)
{
OutputElements(complexType.Particle, complexType.Name);
if (complexType.Particle == null)
{
GetProperties(xmlSchema, complexType.Name);
}
}
}
#region enums
foreach (object xItem in xmlSchema.SchemaTypes.Values)
{
XmlSchemaSimpleType item2 = xItem as XmlSchemaSimpleType;
if (item2 != null)
{
GetEnum(xmlSchema, item2.Name);
}
}
#endregion
#endregion
}
webserv.Save();
}
