private void AssignComplexTypeValues(WsdlType t, XmlSchemaComplexType type)
{
t.XName = type.QualifiedName;
t.IsPrimitiveType = false;
t.Documentation = GetDocumentation(type.Annotation);
t.IsAbstract = type.IsAbstract;
XmlSchemaObjectCollection propertyItems = null;
if (type.ContentModel == null)
{
var typeSequence = type.Particle as XmlSchemaSequence;
if (typeSequence != null)
{
propertyItems = typeSequence.Items;
}
else
{
var typeChoice = type.Particle as XmlSchemaChoice;
propertyItems = typeChoice.Items;
}
}
else
{
var content = type.ContentModel as XmlSchemaComplexContent;
var contentExt = content.Content as XmlSchemaComplexContentExtension;
t.BaseTypeXName = contentExt.BaseTypeName;
var typeSequence = contentExt.Particle as XmlSchemaSequence;
propertyItems = typeSequence.Items;
}
foreach (XmlSchemaElement item in propertyItems)
{
t.Properties.Add(CreateDataProperty(item as XmlSchemaElement));
}
}
private WsdlType CreateSimpleType(XmlSchemaSimpleType type)
{
WsdlType t = null;
if (type.TypeCode == XmlTypeCode.String)
{
var restriction = type.Content as XmlSchemaSimpleTypeRestriction;
if (restriction != null)
{
var enumType = new WsdlEnumType();
t = enumType;
foreach (XmlSchemaFacet facet in restriction.Facets.Cast <XmlSchemaFacet>())
{
var enumFacet = facet as XmlSchemaEnumerationFacet;
if (enumFacet == null)
{
continue;
}
var item = new WsdlEnumItem();
item.Name = enumFacet.Value;
item.Documentation = GetDocumentation(enumFacet.Annotation);
enumType.Items.Add(item);
}
}
}
if (t == null)
{
throw new Exception($"Unhandled SOAP simple type {type.QualifiedName}");
}
t.XName = type.QualifiedName;
t.IsPrimitiveType = true;
t.Documentation = GetDocumentation(type.Annotation);
return(t);
}
private void ImplementISoapableWriteTo(WsdlType t, CodeFile f)
{
var overrideKeyword = t.BaseType == null ? "virtual" : "override";
using (var methodScope = f.CreateMethodScope($"public {overrideKeyword}", "void", "WriteTo", "XElement xE"))
{
if (t.BaseType != null)
{
f.WriteLine("base.WriteTo(xE);");
f.WriteLine($"XmlUtility.SetXsiType(xE, \"{t.XName.Namespace}\", \"{t.XName.Name}\");");
}
if (t.Properties.Count > 0)
{
f.WriteLine("XElement xItem = null;");
}
foreach (var p in t.Properties)
{
bool checkNull = p.AllowMultiple || p.AllowNull;
if (checkNull)
{
f.WriteLine($"if ({p.CodeName} != null)");
f.Ocb();
}
string valueExpr = null;
if (p.AllowMultiple)
{
valueExpr = StringUtil.ToCamelCaseName(p.CodeName + "Item");
f.WriteLine($"foreach (var {valueExpr} in {p.CodeName})");
f.Ocb();
}
else
{
valueExpr = p.CodeName;
if (p.AllowNull && p.DataType.IsPrimitiveType && p.DataType.CodeName != "string" && p.DataType.CodeName != "byte[]")
{
valueExpr += ".Value";
}
}
f.WriteLine($"xItem = new XElement(XName.Get(\"{p.XName.Name}\", \"{p.XName.Namespace}\"));");
if (p.DataType.IsPrimitiveType)
{
f.WriteLine($"xItem.Add({GetSinglePrimitiveTypeToXmlValueExpression(p, valueExpr)});");
}
else
{
f.WriteLine($"{valueExpr}.WriteTo(xItem);");
}
f.WriteLine("xE.Add(xItem);");
if (p.AllowMultiple)
{
f.Ccb(); // close foreach
}
if (checkNull)
{
f.Ccb(); // close check if null
}
}
}
}
private void CodeComplexType(WsdlType t, bool isPublic, string directory, string namespaceName)
{
using (var file = new CodeFile(directory, $"{t.CodeName}.cs"))
{
file.WriteLine("using System;");
file.WriteLine("using System.Collections.Generic;");
file.WriteLine("using System.Xml.Linq;");
file.WriteLine("");
using (var nsScope = file.CreateNamespaceScope(namespaceName))
{
file.Comment(t.Documentation);
string modifier = isPublic ? "public" : "internal";
if (t.IsAbstract)
{
modifier += " abstract";
}
var inherits = new List <string>();
if (t.BaseType != null)
{
inherits.Add(t.BaseType.CodeName);
}
inherits.Add("ISoapable");
using (var classScope = file.CreateClassScope(modifier, t.CodeName, inherits.ToArray()))
{
foreach (var p in t.Properties)
{
file.Comment(p.Documentation);
file.WriteLine($"public {GetPropertyTypeCode(p, false)} {p.CodeName} {{ get; set; }}");
}
ImplementISoapableReadFrom(t, file);
ImplementISoapableWriteTo(t, file);
}
}
}
}
private void CodeApiError(WsdlType t, string directory, string namespaceName)
{
using (var file = new CodeFile(directory, $"{t.CodeName}.cs"))
{
file.WriteLine("using System;");
file.WriteLine("using System.Xml.Linq;");
file.WriteLine("");
using (var nsScope = file.CreateNamespaceScope(namespaceName))
{
file.Comment(t.Documentation);
var abstractKeyword = t.IsAbstract ? " abstract" : "";
using (var classScope = file.CreateClassScope($"public{abstractKeyword}", t.CodeName, "Exception", "ISoapable"))
{
file.WriteLine("public override string Message { get { return ErrorString; } }");
foreach (var p in t.Properties)
{
file.Comment(p.Documentation);
file.WriteLine($"public {GetPropertyTypeCode(p, false)} {p.CodeName} {{ get; set; }}");
}
ImplementISoapableReadFrom(t, file);
ImplementISoapableWriteTo(t, file);
}
}
}
}
private void SetPrimitiveType(WsdlType dataType)
{
dataType.IsPrimitiveType = true;
dataType.CodeName = dataType.XName.Name;
switch (dataType.CodeName)
{
case "boolean": dataType.CodeName = "bool"; break;
case "base64Binary": dataType.CodeName = "byte[]"; break;
}
}
public void AddServiceDescription(ServiceDescription wsdl)
{
var elementLookup = new Dictionary <string, WsdlElementType>();
foreach (XmlSchema schema in wsdl.Types.Schemas)
{
foreach (XmlQualifiedName xname in schema.SchemaTypes.Names)
{
var schemaObj = schema.SchemaTypes[xname] as XmlSchemaType;
if (_typeLookup.ContainsKey(schemaObj.QualifiedName.Name))
{
continue;
}
WsdlType t;
if (schemaObj is XmlSchemaSimpleType)
{
t = CreateSimpleType(schemaObj as XmlSchemaSimpleType);
}
else
{
t = new WsdlType();
AssignComplexTypeValues(t, schemaObj as XmlSchemaComplexType);
}
_typeLookup.Add(t.XName.Name, t);
}
foreach (XmlQualifiedName xname in schema.Elements.Names)
{
var element = schema.Elements[xname] as XmlSchemaElement;
var e = CreateElement(wsdl, element);
elementLookup.Add(e.XName.Name, e);
}
}
_elementLookup.Add(wsdl, elementLookup);
foreach (PortType portType in wsdl.PortTypes)
{
var pt = CreatePortType(wsdl, portType);
_portTypeLookup.Add(pt.XName.Name, pt);
}
foreach (Binding binding in wsdl.Bindings)
{
var b = CreateBinding(wsdl, binding);
_bindingLookup.Add(b.XName.Name, b);
}
foreach (Service service in wsdl.Services)
{
var s = CreateService(wsdl, service);
_serviceLookup.Add(s.XName.Name, s);
}
}
public IEnumerable <WsdlType> GetConcreteChildTypes(WsdlType parentType)
{
var subclasses = _typeLookup.Values.Where(x => x.BaseType == parentType);
foreach (var sc in subclasses)
{
if (sc.IsAbstract)
{
foreach (var secondSubclass in GetConcreteChildTypes(sc))
{
yield return(secondSubclass);
}
}
else
{
yield return(sc);
}
}
}
public void AddXmlSchema(XmlSchema xsd)
{
foreach (XmlQualifiedName xname in xsd.SchemaTypes.Names)
{
var schemaObj = xsd.SchemaTypes[xname] as XmlSchemaType;
if (_typeLookup.ContainsKey(schemaObj.QualifiedName.Name))
{
continue;
}
WsdlType t;
if (schemaObj is XmlSchemaSimpleType)
{
t = CreateSimpleType(schemaObj as XmlSchemaSimpleType);
}
else
{
t = new WsdlType();
AssignComplexTypeValues(t, schemaObj as XmlSchemaComplexType);
}
_typeLookup.Add(t.XName.Name, t);
}
Dictionary <string, WsdlElementType> elementLookup = null;
if (_elementLookup.ContainsKey(DummyWsdl))
{
elementLookup = _elementLookup[DummyWsdl];
}
else
{
elementLookup = new Dictionary <string, WsdlElementType>();
_elementLookup.Add(DummyWsdl, elementLookup);
}
foreach (XmlQualifiedName xname in xsd.Elements.Names)
{
var element = xsd.Elements[xname] as XmlSchemaElement;
var e = CreateElement(DummyWsdl, element);
elementLookup.Add(e.XName.Name, e);
}
}
private void ImplementISoapableReadFrom(WsdlType t, CodeFile f)
{
var overrideKeyword = t.BaseType == null ? "virtual" : "override";
using (var methodScope = f.CreateMethodScope($"public {overrideKeyword}", "void", "ReadFrom", "XElement xE"))
{
if (t.BaseType != null)
{
f.WriteLine("base.ReadFrom(xE);");
}
foreach (var p in t.Properties)
{
if (p.AllowMultiple || p.AllowNull)
{
f.WriteLine($"{p.CodeName} = null;");
}
}
f.WriteLine("foreach (var xItem in xE.Elements())");
f.Ocb();
f.WriteLine("var localName = xItem.Name.LocalName;");
bool isFirst = true;
foreach (var p in t.Properties)
{
f.WriteLine((isFirst ? "" : "else ") + $"if (localName == \"{p.XName.Name}\")");
f.Ocb();
if (p.AllowMultiple)
{
f.WriteLine($"if ({p.CodeName} == null) {p.CodeName} = new {GetPropertyTypeCode(p, false)}();");
if (p.DataType.IsPrimitiveType)
{
f.WriteLine($"{p.CodeName}.Add({GetSinglePrimitiveTypeConversionExpression(p, "xItem.Value")});");
}
else
{
string ItemVarName = StringUtil.ToCamelCaseName(p.CodeName + "Item");
if (p.DataType.IsAbstract || p.DataType.Properties.Any(x => x.IsTypeProperty))
{
f.WriteLine($"var {ItemVarName} = InstanceCreator.Create{p.DataType.CodeName}(xItem);");
}
else
{
f.WriteLine($"var {ItemVarName} = new {p.DataType.CodeName}();");
}
f.WriteLine($"{ItemVarName}.ReadFrom(xItem);");
f.WriteLine($"{p.CodeName}.Add({ItemVarName});");
}
}
else
{
if (p.DataType.IsPrimitiveType)
{
f.WriteLine($"{p.CodeName} = {GetSinglePrimitiveTypeConversionExpression(p, "xItem.Value")};");
}
else
{
if (p.DataType.IsAbstract || p.DataType.Properties.Any(x => x.IsTypeProperty))
{
f.WriteLine($"{p.CodeName} = InstanceCreator.Create{p.DataType.CodeName}(xItem);");
}
else
{
f.WriteLine($"{p.CodeName} = new {p.DataType.CodeName}();");
}
f.WriteLine($"{p.CodeName}.ReadFrom(xItem);");
}
}
f.Ccb();
isFirst = false;
}
f.Ccb(); // close foreach
}
}
