private void AddNamespaceMapping(XmlNamespaceContext namespaceContext, XmlWriterImpl xmlWriter, string prefix, string uri)
{
if (namespaceContext.LookupPrefix(uri) == ValueFactory.Create())
{
xmlWriter.WriteNamespaceMapping(prefix, uri);
}
}
public void TestUnnamedComplexType()
{
var ss = LoadSchema(@"TestData/Schema01.xsd");
var f = new XdtoFactory(ss);
var t = f.Type(uri: "unnamedComplexType", name: "TheComplexType") as XdtoObjectType;
var v = f.Create(t) as XdtoDataObject;
var p = t.Properties.Get("Element");
var pv = f.Create(p.Type) as XdtoDataObject;
var var1Value = f.Create(f.Type(XmlNs.xs, "string"), ValueFactory.Create("value of var1"));
pv.Set("var1", ValueFactory.Create(var1Value));
v.Set("Element", pv);
var w = new XmlWriterImpl();
w.SetString();
f.WriteXml(w, v, "value");
var serialized = w.Close().AsString();
Console.WriteLine(serialized);
var r = new XmlReaderImpl();
r.SetString(serialized);
var checkObject = f.ReadXml(r) as XdtoDataObject;
var checkValue = (checkObject.Get("Element") as XdtoDataObject).Get("var1").AsString();
Console.WriteLine($"got {checkValue}");
}
public string Handle(string requestBody)
{
var reader = new XmlReaderImpl();
reader.SetString(requestBody);
var writer = new XmlWriterImpl();
writer.SetString();
writer.WriteStartElement("Envelope", xmlns_soap);
writer.WriteNamespaceMapping("soap", xmlns_soap);
writer.WriteStartElement("Body", xmlns_soap);
try
{
Handle(reader, writer);
}
catch (Exception exc)
{
WriteFault(writer, exc.Message);
}
writer.WriteEndElement(); // Body
writer.WriteEndElement(); // Envelope
var responseText = writer.Close().AsString();
return(responseText);
}
public void WriteRequestBody(XmlWriterImpl writer,
XdtoSerializerImpl serializer,
IValue [] arguments)
{
foreach (var messagePart in Parameters.Parts)
{
writer.WriteStartElement(messagePart.ElementName, messagePart.NamespaceUri);
foreach (var param in messagePart.Parameters)
{
if (param.ParameterDirection == ParameterDirectionEnum.Out)
{
continue;
}
var argumentIndex = _indexes [param.Name];
var typeAssignment = XmlTypeAssignmentEnum.Implicit;
if (param.Type is XdtoValueType)
{
typeAssignment = XmlTypeAssignmentEnum.Explicit;
}
serializer.WriteXml(writer, arguments [argumentIndex], param.Name, messagePart.NamespaceUri, typeAssignment);
}
writer.WriteEndElement(); // messagePart.ElementName
}
}
public void WriteXML(XmlWriterImpl xmlWriter,
IValue value,
string name,
XMLTypeAssignment typeAssigment = XMLTypeAssignment.Implicit,
XMLForm form = XMLForm.Element)
{
XMLExpandedName xmlType;
switch (value.DataType)
{
case DataType.Undefined:
WriteXMLUndefined(xmlWriter, name, form);
break;
case DataType.String:
xmlType = new XMLExpandedName(XmlSchema.InstanceNamespace, "string");
WriteXMLSimpleData(xmlWriter, name, value, xmlType, typeAssigment, form);
break;
case DataType.Number:
xmlType = new XMLExpandedName(XmlSchema.InstanceNamespace, "decimal");
WriteXMLSimpleData(xmlWriter, name, value, xmlType, typeAssigment, form);
break;
case DataType.Boolean:
xmlType = new XMLExpandedName(XmlSchema.InstanceNamespace, "boolean");
WriteXMLSimpleData(xmlWriter, name, value, xmlType, typeAssigment, form);
break;
case DataType.Date:
xmlType = new XMLExpandedName(XmlSchema.InstanceNamespace, "dateTime");
WriteXMLSimpleData(xmlWriter, name, value, xmlType, typeAssigment, form);
break;
case DataType.Object:
IRuntimeContextInstance valueObject = value.AsObject();
if (valueObject is IXDTOSerializableXML seriazable)
{
seriazable.WriteXML(xmlWriter, this);
}
else
{
throw RuntimeException.InvalidArgumentType();
}
break;
default:
throw RuntimeException.InvalidArgumentType();
}
}
private void WriteFault(XmlWriterImpl writer, string faultString)
{
writer.WriteStartElement("Fault", xmlns_soap);
writer.WriteStartElement("faultString", xmlns_soap);
writer.WriteText(faultString);
writer.WriteEndElement(); // faultString
writer.WriteEndElement(); // Fault
}
public void Handle(XmlReaderImpl requestReader,
XmlWriterImpl responseWriter)
{
var F = new XdtoFactory();
var S = XdtoSerializerImpl.Constructor(ValueFactory.Create(F)) as XdtoSerializerImpl;
var inputMessage = F.ReadXml(requestReader) as XdtoDataObject;
var body = inputMessage.Get("Body") as XdtoDataObject;
var requestProperty = body.Properties().Get(0);
var methodName = requestProperty.LocalName;
if (!operations.ContainsKey(methodName))
{
// TODO: SoapException
throw new RuntimeException($"method not found {methodName}");
}
var op = operations[methodName];
// TODO: отдать разбор в операцию
var args = new List <IValue>();
var callParams = body.Get(body.Properties().Get(0)) as XdtoDataObject;
foreach (var pv in callParams.Properties())
{
var paramName = pv.LocalName;
var p = op.Parameters.Get(paramName);
var xdtoValue = callParams.GetXdto(pv);
var ivalue = S.ReadXdto(xdtoValue);
if (p.ParameterDirection != ParameterDirectionEnum.In)
{
ivalue = Variable.Create(ivalue, paramName);
}
args.Add(ivalue);
}
var handler = operationsMapper[op];
var methodIdx = handler.FindMethod(methodName);
var mi = handler.GetMethodInfo(methodIdx);
IValue result = null;
if (mi.IsFunction)
{
handler.CallAsFunction(methodIdx, args.ToArray(), out result);
}
else
{
handler.CallAsProcedure(methodIdx, args.ToArray());
}
op.WriteResponseBody(responseWriter, S, result, args.ToArray());
}
public void WriteXml(XmlWriterImpl xmlWriter,
IXdtoValue value,
string localName,
string namespaceUri = null,
XmlTypeAssignmentEnum?typeAssignment = null,
XmlFormEnum?xmlForm = null)
{
xmlForm = xmlForm ?? XmlFormEnum.Element;
typeAssignment = typeAssignment ?? XmlTypeAssignmentEnum.Implicit;
if (xmlForm == XmlFormEnum.Element)
{
xmlWriter.WriteStartElement(localName, namespaceUri);
if (typeAssignment == XmlTypeAssignmentEnum.Implicit)
{
WriteTypeAttribute(xmlWriter, ValueFactory.Create(value));
}
if (value == null)
{
xmlWriter.WriteAttribute("nil", XmlNs.xsi, "true");
}
else if (value is XdtoDataObject)
{
WriteXdtoObject(xmlWriter, value as XdtoDataObject);
}
else if (value is XdtoDataValue)
{
var dataValue = value as XdtoDataValue;
xmlWriter.WriteText(dataValue.LexicalValue);
}
else
{
xmlWriter.WriteText(value.ToString());
}
xmlWriter.WriteEndElement();
}
else if (xmlForm == XmlFormEnum.Attribute)
{
xmlWriter.WriteAttribute(localName, namespaceUri, value.ToString());
}
else if (xmlForm == XmlFormEnum.Text)
{
xmlWriter.WriteText(value.ToString()); // TODO: XmlString ??
}
else
{
throw new NotSupportedException("Какой-то новый тип для XML");
}
}
public void WriteXml(XmlWriterImpl xmlWriter,
IValue value,
string localName,
string namespaceUri,
XmlTypeAssignmentEnum?typeAssignment = null,
XmlFormEnum?xmlForm = null)
{
xmlForm = xmlForm ?? XmlFormEnum.Element;
typeAssignment = typeAssignment ?? XmlTypeAssignmentEnum.Implicit;
var xdtoValue = WriteXdto(value);
XdtoFactory.WriteXml(xmlWriter, xdtoValue, localName, namespaceUri, typeAssignment, xmlForm);
}
public void WriteXML(XmlWriterImpl xmlWriter,
IValue value,
XMLTypeAssignment typeAssigment = XMLTypeAssignment.Implicit,
XMLForm form = XMLForm.Element)
{
switch (value.DataType)
{
case DataType.Undefined:
WriteXML(xmlWriter, value, "Undefined", typeAssigment, form);
break;
case DataType.String:
WriteXML(xmlWriter, value, "string", typeAssigment, form);
break;
case DataType.Number:
WriteXML(xmlWriter, value, "decimal", typeAssigment, form);
break;
case DataType.Boolean:
WriteXML(xmlWriter, value, "boolean", typeAssigment, form);
break;
case DataType.Date:
WriteXML(xmlWriter, value, "dateTime", typeAssigment, form);
break;
case DataType.Object:
IRuntimeContextInstance valueObject = value.AsObject();
if (valueObject is IXDTOSerializableXML seriazable)
{
seriazable.WriteXML(xmlWriter, this);
}
else
{
throw RuntimeException.InvalidArgumentType();
}
break;
default:
throw RuntimeException.InvalidArgumentType();
}
}
private void WriteXMLUndefined(XmlWriterImpl xmlWriter, string name, XMLForm form)
{
if (form == XMLForm.Element)
{
XmlNamespaceContext namespaceContext = xmlWriter.NamespaceContext;
AddNamespaceMapping(namespaceContext, xmlWriter, "", XmlSchema.Namespace);
AddNamespaceMapping(namespaceContext, xmlWriter, "xsi", XmlSchema.InstanceNamespace);
xmlWriter.WriteStartElement(name);
xmlWriter.WriteStartAttribute("nil", XmlSchema.InstanceNamespace);
xmlWriter.WriteText("true");
xmlWriter.WriteEndAttribute();
xmlWriter.WriteEndElement();
}
}
private void WriteXMLSimpleData(XmlWriterImpl xmlWriter,
string name,
IValue value,
XMLExpandedName type,
XMLTypeAssignment typeAssigment,
XMLForm form)
{
XmlNamespaceContext namespaceContext;
string xmlValue = XMLString(value);
switch (form)
{
case XMLForm.Attribute:
namespaceContext = xmlWriter.NamespaceContext;
AddNamespaceMapping(namespaceContext, xmlWriter, "", XmlSchema.Namespace);
xmlWriter.WriteStartAttribute(name);
xmlWriter.WriteText(xmlValue);
xmlWriter.WriteEndAttribute();
break;
case XMLForm.Text:
xmlWriter.WriteText(xmlValue);
break;
default:
xmlWriter.WriteStartElement(name);
namespaceContext = xmlWriter.NamespaceContext;
AddNamespaceMapping(namespaceContext, xmlWriter, "", XmlSchema.Namespace);
AddNamespaceMapping(namespaceContext, xmlWriter, "xsi", XmlSchema.InstanceNamespace);
if (typeAssigment == XMLTypeAssignment.Explicit)
{
xmlWriter.WriteStartAttribute("type", XmlSchema.InstanceNamespace);
xmlWriter.WriteText(type.LocalName);
xmlWriter.WriteEndAttribute();
}
xmlWriter.WriteText(xmlValue);
xmlWriter.WriteEndElement();
break;
}
}
public void TestRouter()
{
var router = new Router("OneService", "http://oscript.io/example/");
router.AddHandler(new RouterTest());
// Console.WriteLine(router.GenerateWsdl());
var xmlBody = XmlWriterImpl.Create();
xmlBody.SetString(ValueFactory.Create("UTF-8"));
xmlBody.WriteStartElement("soap:Envelope");
xmlBody.WriteNamespaceMapping("xsi", "http://www.w3.org/2001/XMLSchema-instance");
xmlBody.WriteNamespaceMapping("xsd", "http://www.w3.org/2001/XMLSchema");
xmlBody.WriteNamespaceMapping("soap", "http://schemas.xmlsoap.org/soap/envelope/");
xmlBody.WriteNamespaceMapping("s", "http://oscript.io/example/");
xmlBody.WriteStartElement("soap:Body");
xmlBody.WriteStartElement("s:Sum");
xmlBody.WriteStartElement("s:p0");
xmlBody.WriteAttribute("xsi:type", "xsd:decimal");
xmlBody.WriteText("1");
xmlBody.WriteEndElement(); // s:p0
xmlBody.WriteStartElement("s:p1");
xmlBody.WriteAttribute("xsi:type", "xsd:decimal");
xmlBody.WriteText("2");
xmlBody.WriteEndElement(); // s:p1
xmlBody.WriteEndElement(); // s:Sum
xmlBody.WriteEndElement(); // soap:Body
xmlBody.WriteEndElement(); // soap:Envelope
var requestString = xmlBody.Close().ToString();
Console.WriteLine(requestString);
var responseString = router.Handle(requestString);
Console.WriteLine(responseString);
}
private void WriteXdtoObject(XmlWriterImpl xmlWriter,
XdtoDataObject obj)
{
obj.Validate();
if (obj.Type().Sequenced)
{
WriteXdtoSequence(xmlWriter, obj.Sequence());
return;
}
foreach (var property in obj.Properties())
{
var typeAssignment = XmlTypeAssignmentEnum.Explicit;
if (property.UpperBound != 1)
{
// это список
var value = obj.GetList(property) as XdtoList;
foreach (var listElement in value)
{
WriteXml(xmlWriter, listElement,
property.LocalName,
property.NamespaceURI,
typeAssignment,
property.Form);
}
}
else
{
var value = obj.GetXdto(property);
if (value != null || property.Nillable)
{
WriteXml(xmlWriter, value,
property.LocalName,
property.NamespaceURI,
typeAssignment,
property.Form);
}
}
}
}
public static IWriter CreateWriter(TextWriter output, Format format)
{
switch (format)
{
case Format.Xml:
var xws = new XmlWriterSettings {
ConformanceLevel = ConformanceLevel.Fragment
};
return(XmlWriterImpl.Create(output, xws));
#if FULL
case Format.Json:
return(JsonWriterImpl.Create(output));
case Format.JsonML:
return(JsonMLWriter.Create(output));
#endif
default:
throw new NotSupportedException("format");
}
}
// Особенности реализации: возвращаемое значение и исходящие параметры
// передаём ОДНИМ сообщением, хотя протокол разрешает несколько сообщений
public void WriteResponseBody(XmlWriterImpl writer,
XdtoSerializerImpl serializer,
IValue returnValue,
IValue [] arguments)
{
writer.WriteStartElement(ReturnValue.MessagePartName, NamespaceUri);
serializer.WriteXml(writer, returnValue, "return", NamespaceUri);
foreach (var param in Parameters)
{
if (param.ParameterDirection == ParameterDirectionEnum.In)
{
continue;
}
var argumentIndex = _indexes [param.Name];
serializer.WriteXml(writer, arguments [argumentIndex], param.Name, NamespaceUri);
}
writer.WriteEndElement(); // messagePartName
}
private void WriteXdtoSequence(XmlWriterImpl xmlWriter,
XdtoSequence sequence)
{
foreach (var element in sequence)
{
if (element == null)
{
// TODO: надо ли что-нибудь делать???
}
else if (element is XdtoSequenceStringElement)
{
xmlWriter.WriteText((element as XdtoSequenceStringElement).Text);
}
else if (element is XdtoSequenceValueElement)
{
var obj = element as XdtoSequenceValueElement;
WriteXml(xmlWriter, obj.Value,
obj.Property.LocalName, obj.Property.NamespaceURI,
XmlTypeAssignmentEnum.Explicit,
obj.Property.Form);
}
}
}
private void WriteTypeAttribute(XmlWriterImpl xmlWriter,
IValue value)
{
string typeName;
string typeUri;
if (value is XdtoDataObject)
{
var obj = value as XdtoDataObject;
typeUri = obj.Type().NamespaceUri;
typeName = obj.Type().Name;
}
else if (value is XdtoDataValue)
{
var obj = value as XdtoDataValue;
typeUri = obj.Type().NamespaceUri;
typeName = obj.Type().Name;
}
else
{
typeName = "string";
typeUri = XmlNs.xs;
}
var ns = xmlWriter.LookupPrefix(typeUri)?.AsString();
if (string.IsNullOrEmpty(ns))
{
// WriteAttribute(name, ns, value) при создании нового префикса
// не опознаёт префиксы, записанные через WriteNamespaceMapping
var prefixIndex = xmlWriter.NamespaceContext.NamespaceMappings().Count() + 2; // TODO: Костыль с +2
var prefixDepth = xmlWriter.NamespaceContext.Depth;
ns = string.Format("d{0}p{1}", prefixDepth, prefixIndex);
xmlWriter.WriteNamespaceMapping(ns, typeUri);
}
xmlWriter.WriteAttribute("type", XmlNs.xsi, string.Format("{0}:{1}", ns, typeName));
}
public void TestXdto()
{
const string anyXml = @"<number>1</number>";
var reader = XmlReaderImpl.Create() as XmlReaderImpl;
reader.SetString(anyXml);
var factory = XdtoFactory.Constructor() as XdtoFactory;
var expectedType = factory.Type(new XmlDataType("int"));
var anyValue = factory.ReadXml(reader, expectedType) as XdtoDataValue;
if (anyValue == null)
{
throw new Exception("XDTO не разобрался!");
}
var writer = XmlWriterImpl.Create() as XmlWriterImpl;
writer.SetString();
factory.WriteXml(writer, anyValue, "number");
var serializedResult = writer.Close().AsString();
Console.WriteLine("Original : {0}", anyXml);
Console.WriteLine("Generated: {0}", serializedResult);
reader = XmlReaderImpl.Create() as XmlReaderImpl;
reader.SetString(serializedResult);
var anyValueTypeExtraction = factory.ReadXml(reader) as XdtoDataValue;
if (anyValueTypeExtraction == null)
{
throw new Exception("Новый XDTO не разобрался!");
}
Console.WriteLine("Serialized:{0}", anyValueTypeExtraction.Value);
}
/// <summary>
/// Serializes given object.
/// </summary>
/// <typeparam name="T">The object type.</typeparam>
/// <param name="schema">Serialization schema.</param>
/// <param name="writer">The xml writer.</param>
/// <param name="obj">The object to serialize.</param>
public static void Write <T>(this IScope schema, XmlWriter writer, T obj)
{
using (var impl = XmlWriterImpl.Create(writer))
Write(schema, impl, obj);
}
public override void CallAsFunction(int methodNumber, IValue [] arguments, out IValue retValue)
{
var operation = _operations [methodNumber];
retValue = ValueFactory.Create();
ConnectIfNeeded();
var headers = new MapImpl();
headers.Insert(ValueFactory.Create("Content-Type"), ValueFactory.Create("application/xml"));
var xmlBody = XmlWriterImpl.Create();
xmlBody.SetString(ValueFactory.Create("UTF-8"));
xmlBody.WriteStartElement("soap:Envelope");
xmlBody.WriteNamespaceMapping("xsi", "http://www.w3.org/2001/XMLSchema-instance");
xmlBody.WriteNamespaceMapping("xsd", "http://www.w3.org/2001/XMLSchema");
xmlBody.WriteNamespaceMapping("soap", "http://schemas.xmlsoap.org/soap/envelope/");
xmlBody.WriteNamespaceMapping("s", Endpoint.Interface.NamespaceURI);
xmlBody.WriteStartElement("soap:Body");
var serializer = XdtoSerializerImpl.Constructor(XdtoFactory) as XdtoSerializerImpl;
operation.WriteRequestBody(xmlBody, serializer, arguments);
xmlBody.WriteEndElement(); // soap:Body
xmlBody.WriteEndElement(); // soap:Envelope
var requestString = xmlBody.Close().ToString();
if (DoDebug)
{
Console.WriteLine(requestString);
}
var responseText = _transport.Handle(requestString);
var xmlResult = XmlReaderImpl.Create() as XmlReaderImpl;
if (DoDebug)
{
Console.WriteLine(responseText);
}
// TODO: Отдать на разбор фабрике
xmlResult.SetString(responseText);
var result = operation.ParseResponse(xmlResult, serializer);
if (result is SoapExceptionResponse)
{
throw new ScriptEngine.Machine.RuntimeException((result as SoapExceptionResponse).FaultMessage);
}
var soapResponse = result as SuccessfulSoapResponse;
retValue = soapResponse.RetValue;
foreach (var outParamData in soapResponse.OutputParameters)
{
var argument = arguments [outParamData.Key] as IVariable;
if (argument == null)
{
continue;
}
argument.Value = outParamData.Value;
}
}
public string GenerateWsdl()
{
var writer = new XmlWriterImpl();
writer.SetString();
writer.WriteXMLDeclaration();
writer.WriteStartElement("definitions");
writer.WriteNamespaceMapping("", "http://schemas.xmlsoap.org/wsdl/");
writer.WriteNamespaceMapping("soap12bind", "http://schemas.xmlsoap.org/wsdl/soap12/");
writer.WriteNamespaceMapping("soapbind", "http://schemas.xmlsoap.org/wsdl/soap/");
writer.WriteNamespaceMapping("tns", NamespaceUri);
writer.WriteAttribute("name", Name);
writer.WriteAttribute("targetNamespace", NamespaceUri);
#region definitions/types
writer.WriteStartElement("types");
writer.WriteStartElement("xs:schema");
writer.WriteNamespaceMapping("xs", "http://www.w3.org/2001/XMLSchema");
writer.WriteNamespaceMapping("tns", NamespaceUri);
writer.WriteAttribute("targetNamespace", NamespaceUri);
writer.WriteAttribute("attributeFormDefault", "unqualified");
writer.WriteAttribute("elementFormDefault", "qualified");
foreach (var operation in operations.Values)
{
foreach (var part in operation.Parameters.Parts)
{
writer.WriteStartElement("xs:element");
writer.WriteAttribute("name", part.Name);
writer.WriteStartElement("xs:complexType");
writer.WriteStartElement("xs:sequence");
foreach (var param in part.Parameters)
{
if (param.ParameterDirection == ParameterDirectionEnum.Out)
{
continue;
}
writer.WriteStartElement("xs:element");
writer.WriteAttribute("name", param.Name);
writer.WriteAttribute("type", "xs:anyType");
writer.WriteEndElement(); // xs:element
}
writer.WriteEndElement(); // xs:sequence
writer.WriteEndElement(); // xs:complexType
writer.WriteEndElement(); // xs:element
}
writer.WriteStartElement("xs:element");
writer.WriteAttribute("name", operation.ReturnValue.MessagePartName);
writer.WriteStartElement("xs:complexType");
writer.WriteStartElement("xs:sequence");
writer.WriteStartElement("xs:element");
writer.WriteAttribute("name", "return");
writer.WriteAttribute("type", "xs:anyType");
writer.WriteEndElement(); // xs:element
foreach (var param in operation.Parameters)
{
if (param.ParameterDirection == ParameterDirectionEnum.In)
{
continue;
}
writer.WriteStartElement("xs:element");
writer.WriteAttribute("name", param.Name);
writer.WriteAttribute("type", "xs:anyType");
writer.WriteEndElement(); // xs:element
}
writer.WriteEndElement(); // xs:sequence
writer.WriteEndElement(); // xs:complexType
writer.WriteEndElement(); // xs:element
}
writer.WriteEndElement(); // xs:schema
writer.WriteEndElement(); // types
#endregion
#region definitions/messages
foreach (var operation in operations.Values)
{
writer.WriteStartElement("message");
writer.WriteAttribute("name", string.Format("{0}RequestMessage", operation.Name));
foreach (var part in operation.Parameters.Parts)
{
writer.WriteStartElement("part");
writer.WriteAttribute("name", part.Name);
writer.WriteAttribute("element", part.ElementName);
writer.WriteEndElement(); // part
}
writer.WriteEndElement(); // message
writer.WriteStartElement("message");
writer.WriteAttribute("name", string.Format("{0}ResponseMessage", operation.Name));
writer.WriteStartElement("part");
writer.WriteAttribute("name", "parameters");
writer.WriteAttribute("element", operation.ReturnValue.MessagePartName);
writer.WriteEndElement(); // part
writer.WriteEndElement(); // message
}
#endregion
#region definitions/portType
var portTypeName = string.Format("{0}PortType", Name);
writer.WriteStartElement("portType");
writer.WriteAttribute("name", portTypeName);
foreach (var operation in operations.Values)
{
writer.WriteStartElement("operation");
writer.WriteAttribute("name", operation.Name);
writer.WriteStartElement("input");
writer.WriteAttribute("message", string.Format("{0}RequestMessage", operation.Name));
writer.WriteEndElement(); // input
writer.WriteStartElement("output");
writer.WriteAttribute("message", string.Format("{0}ResponseMessage", operation.Name));
writer.WriteEndElement(); // output
writer.WriteEndElement(); // operation
}
writer.WriteEndElement(); // portType
#endregion
#region definitions/binding
var mainBindingName = string.Format("{0}Binding", Name);
writer.WriteStartElement("binding");
writer.WriteAttribute("name", mainBindingName);
writer.WriteAttribute("type", portTypeName);
writer.WriteStartElement("soapbind:binding");
writer.WriteAttribute("style", "document");
writer.WriteAttribute("transport", "http://schemas.xmlsoap.org/soap/http");
writer.WriteEndElement(); // soapbind:binding
foreach (var operation in operations.Values)
{
var soapActionString = string.Format("{0}#{1}:{2}", NamespaceUri, Name, operation.Name);
writer.WriteStartElement("operation");
writer.WriteAttribute("name", operation.Name);
writer.WriteStartElement("soapbind:operation");
writer.WriteAttribute("style", "document");
writer.WriteAttribute("soapAction", soapActionString);
writer.WriteStartElement("input");
writer.WriteStartElement("soapbind:body");
writer.WriteAttribute("use", "literal");
writer.WriteEndElement(); // soapbind:body
writer.WriteEndElement(); // input
writer.WriteStartElement("output");
writer.WriteStartElement("soapbind:body");
writer.WriteAttribute("use", "literal");
writer.WriteEndElement(); // soapbind:body
writer.WriteEndElement(); // output
writer.WriteEndElement(); // soapbind:operation
writer.WriteEndElement(); // operation
}
writer.WriteEndElement(); // binding
#endregion
#region definitions/service
var serviceUrl = "http://localhost/service";
writer.WriteStartElement("service");
writer.WriteStartElement("port");
var mainPortName = string.Format("{0}Soap", Name);
writer.WriteAttribute("name", mainPortName);
writer.WriteAttribute("binding", string.Format("tns:{0}", mainBindingName));
writer.WriteStartElement("documentation");
writer.WriteEndElement(); // documentation
writer.WriteStartElement("soapbind:address");
writer.WriteAttribute("location", serviceUrl);
writer.WriteEndElement(); // soapbind:address
writer.WriteEndElement(); // port
writer.WriteEndElement(); // service
#endregion
writer.WriteEndElement(); // definitions
return(writer.Close().AsString());
}
