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 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 IXdtoValue ReadXml(XmlReaderImpl reader, IXdtoType expectedType, XdtoFactory factory) { var lexicalValue = reader.Value; var value = ValueFactory.Create(lexicalValue); return(new XdtoDataValue(expectedType as XdtoValueType, lexicalValue, value)); }
public IXdtoValue ReadXml(XmlReaderImpl reader, IXdtoType type, XdtoFactory factory) { var lexicalValue = reader.Value; var internalValue = ValueFactory.Create(lexicalValue); return(new XdtoDataValue(this, lexicalValue, internalValue)); }
/// <summary> /// Reads specified object from given xml string. /// </summary> /// <typeparam name="T">The object type.</typeparam> /// <param name="schema">Serialization schema.</param> /// <param name="xml">The xml string to parse.</param> /// <param name="obj">The object to deserialize.</param> public static void ReadXmlString <T>(this IScope schema, string xml, T obj) { using (var input = new StringReader(xml)) using (var reader = XmlReaderImpl.Create(input)) { Read(schema, reader, obj); } }
public IXdtoValue ReadXml(XmlReaderImpl reader, IXdtoType expectedType, XdtoFactory factory) { var lexicalValue = reader.Value; var xmlDateTimeValue = XmlConvert.ToDateTime(lexicalValue, XmlDateTimeSerializationMode.Unspecified); var value = ValueFactory.Create(xmlDateTimeValue); return(new XdtoDataValue(expectedType as XdtoValueType, lexicalValue, value)); }
public IValue ReadXml(XmlReaderImpl reader, TypeTypeValue requestedType = null) { var xdtoValue = XdtoFactory.ReadXml(reader); if (xdtoValue is IXdtoValue) { return(ReadXdto(xdtoValue as IXdtoValue)); } return(xdtoValue); }
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 static IReader CreateReader(TextReader input, Format format, XNamespace rootNamespace) { switch (format) { case Format.Xml: return(XmlReaderImpl.Create(input)); #if FULL case Format.Json: return(JsonReaderImpl.Create(rootNamespace, input)); case Format.JsonML: return(JsonMLReader.Create(input)); #endif default: throw new NotSupportedException("format"); } }
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); }
public void TestWsdl() { // var def = new Definitions("http://vm21297.hv8.ru:10080/httpservice/ws/complex.1cws?wsdl", "default"); var def = new Definitions(@"D:\temp\Bases1C.wsdl", "default"); Console.WriteLine("Def has {0} services.", def.Services.Count()); foreach (var service in def.Services) { Console.WriteLine("\tService {0} has {1} endpoints", service.Name, service.Endpoints.Count()); foreach (var endpoint in service.Endpoints) { Console.WriteLine("\t\tEndpoint {0} as {1} operations", endpoint.Name, endpoint.Interface.Operations.Count()); foreach (var operation in endpoint.Interface.Operations) { Console.WriteLine("\t\t\tOperation {0}", operation.Name); } } } var proxy = Proxy.Constructor(def, "http://xfit.local/1C/Bases1C", "Bases1C", "Bases1CSoap") as Proxy; proxy.User = "******"; var methodIndex = proxy.FindMethod("getBasesList"); Console.WriteLine($"Method `getBasesList` is {methodIndex}"); var responseType = proxy.XdtoFactory.Type("http://xfit.local/1C/Bases1C", "getBasesListResponse"); var xri = new XmlReaderImpl(); xri.OpenFile(@"D:\temp\testresponse.xml"); xri.Read(); xri.Read(); xri.Read(); var response = proxy.XdtoFactory.ReadXml(xri, responseType); }
public IValue ReadXml(XmlReaderImpl reader, IXdtoType type = null) { if (reader.MoveToContent() == null) { // TODO: бросить исключение?? return(null); } if (type == null) { var explicitType = reader.GetAttribute(ValueFactory.Create("type"), XmlNs.xsi); if (explicitType.DataType == DataType.Undefined) { type = new XdtoObjectType(); } else { var defaultNamespace = reader.NamespaceContext.DefaultNamespace; // Задан тип - пытаемся его распознать var sType = explicitType.AsString(); var nameElements = sType.Split(':'); var typeUri = nameElements.Count() > 1 ? nameElements [0] : defaultNamespace; var typeName = nameElements.Count() > 1 ? nameElements [1] : nameElements [0]; var nsMapping = reader.NamespaceContext.LookupNamespaceUri(typeUri); if (nsMapping != null && nsMapping.DataType == DataType.String) { typeUri = nsMapping.AsString(); } type = this.Type(typeUri, typeName); } } if (type is XdtoObjectType) { return(ValueFactory.Create(type.Reader.ReadXml(reader, type, this))); } var xmlNodeTypeEnum = XmlNodeTypeEnum.CreateInstance(); var xmlElementStart = xmlNodeTypeEnum.FromNativeValue(XmlNodeType.Element); var xmlElementEnd = xmlNodeTypeEnum.FromNativeValue(XmlNodeType.EndElement); if (type is XdtoValueType) { if (reader.NodeType.Equals(xmlElementStart)) { reader.Read(); } var result = type.Reader.ReadXml(reader, type, this); if (!reader.NodeType.Equals(xmlElementEnd)) { reader.Skip(); } var pd = new PrimitiveValuesSerializer(); return(pd.DeserializeXdto(result)); } throw new NotSupportedException("Неожиданный тип XDTO!"); }
public IXdtoValue ReadXml(XmlReaderImpl reader, IXdtoType expectedType, XdtoFactory factory) { // TODO: дублирование кода в трёх ветках var result = new XdtoDataObject(this, null, null); // TODO: Перевести XML на простые перечисления var xmlNodeTypeEnum = XmlNodeTypeEnum.CreateInstance(); var xmlElementStart = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.Element); var xmlText = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.Text); var xmlElementEnd = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.EndElement); while (reader.ReadAttribute()) { if (reader.NamespaceURI.Equals("http://www.w3.org/2000/xmlns/") || reader.NamespaceURI.Equals(XmlNs.xsi) && reader.LocalName.Equals("type")) { continue; } var propertyName = reader.LocalName; var attributeNamespace = reader.NamespaceURI; var attributeProperty = AllProperties().FirstOrDefault(p => p.Form == XmlFormEnum.Attribute && p.LocalName.Equals(propertyName) && p.NamespaceURI.Equals(attributeNamespace)); if (attributeProperty == null) { if (!Open) { throw new XdtoException($"Ошиба разбора XDTO: Получили неизвестный атрибут {propertyName}"); } var type = factory.Type(new XmlDataType("string")); attributeProperty = new XdtoProperty(null, result, XmlFormEnum.Attribute, NamespaceUri, propertyName, 1, -1, type); // TODO: lower / upper для открытого типа } var attributeValue = attributeProperty.Type.Reader.ReadXml(reader, attributeProperty.Type, factory); result.Set(attributeProperty, ValueFactory.Create(attributeValue)); } while (reader.Read()) { if (reader.NodeType.Equals(xmlElementEnd)) { // TODO: result.Validate() return(result); } if (reader.NodeType.Equals(xmlText)) { // надо найти свойство с Form=Text // оно должно быть одно var textProperty = AllProperties().FirstOrDefault((p) => p.Form == XmlFormEnum.Text); IXdtoType type; IValue textValue; if (textProperty == null) { if (!Open) { throw new XdtoException($"Ошибка разбора XDTO: Текст {reader.Value} в неположенном месте при разборе типа {this}!"); } textProperty = new XdtoProperty(null, result, XmlFormEnum.Text, NamespaceUri, "#text"); type = factory.Type(new XmlDataType("string")); textValue = ValueFactory.Create(reader.Value); } else { type = textProperty.Type; textValue = ValueFactory.Create(type.Reader.ReadXml(reader, type, factory)); } if (Sequenced) { result.Sequence().Add(textValue.AsString()); } else { result.Set(textProperty, textValue); } } else if (reader.NodeType.Equals(xmlElementStart)) { var localName = reader.LocalName; var ns = reader.NamespaceURI; var property = AllProperties().FirstOrDefault((p) => p.LocalName.Equals(localName) && p.NamespaceURI.Equals(ns) && p.Form == XmlFormEnum.Element); if (property == null) { if (!Open) { throw new XdtoException($"Ошибка разбора XDTO: Получили неизвестный элемент {localName}"); } // TODO: lower / upper для открытого типа property = new XdtoProperty(null, result, XmlFormEnum.Element, ns, localName, 1, 1); } var elementValue = factory.ReadXml(reader, property.Type); // TODO: Разбор anyType if (property.UpperBound != 1) { // TODO: проверка на null - на отсутствие/наличие списка (result.GetList(property) as XdtoList).Add(elementValue); } else { result.Set(property, elementValue); } } } throw new XdtoException("Ошибка разбора XDTO!"); }
public IParsedResponse ParseResponse(XmlReaderImpl reader, XdtoSerializerImpl serializer) { var retValue = ValueFactory.Create(); var outputParams = new Dictionary <int, IValue> (); var xmlNodeTypeEnum = XmlNodeTypeEnum.CreateInstance(); var xmlElementStart = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.Element); if (!reader.Read() || !reader.LocalName.Equals("Envelope") || !reader.NodeType.Equals(xmlElementStart) // TODO: перевести XML на простые перечисления ) { return(new SoapExceptionResponse("Wrong response!")); } reader.MoveToContent(); if (!reader.Read() || !reader.LocalName.Equals("Body") || !reader.NodeType.Equals(xmlElementStart) // TODO: перевести XML на простые перечисления ) { return(new SoapExceptionResponse("Wrong response!")); } if (!reader.Read()) { return(new SoapExceptionResponse("Wrong response!")); } if (reader.LocalName.Equals("Fault") && reader.NodeType.Equals(xmlElementStart)) { reader.Read(); while (!(reader.LocalName.Equals("faultString") && reader.NodeType.Equals(xmlElementStart))) { if (!reader.Read()) { return(new SoapExceptionResponse("Wrong response!")); } } reader.Read(); var faultString = reader.Value; return(new SoapExceptionResponse(faultString)); } var xdtoResult = serializer.XdtoFactory.ReadXml(reader, ReturnValue.ResponseType ?? ReturnValue.Type) as XdtoDataObject; retValue = xdtoResult.Get("return"); if (retValue is IXdtoValue) { retValue = serializer.ReadXdto(retValue as IXdtoValue); } foreach (var param in Parameters) { if (param.ParameterDirection == ParameterDirectionEnum.In) { continue; } var argumentIndex = _indexes [param.Name]; IValue paramValue = xdtoResult.Get(param.Name); if (paramValue is IXdtoValue) { paramValue = serializer.ReadXdto(paramValue as IXdtoValue); } outputParams.Add(argumentIndex, paramValue); } return(new SuccessfulSoapResponse(retValue, outputParams)); }
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; } }
/// <summary> /// Reads object with given reader. /// </summary> /// <typeparam name="T">The object type.</typeparam> /// <param name="schema">Serialization schema.</param> /// <param name="reader">The xml reader.</param> public static T Read <T>(this IScope schema, XmlReader reader) { using (var impl = XmlReaderImpl.Create(reader)) return(Read <T>(schema, impl)); }
/// <summary> /// Reads specified object with given reader. /// </summary> /// <typeparam name="T">The object type.</typeparam> /// <param name="schema">Serialization schema.</param> /// <param name="reader">The xml reader.</param> /// <param name="obj">The object to deserialize.</param> public static void Read <T>(this IScope schema, XmlReader reader, T obj) { using (var impl = XmlReaderImpl.Create(reader)) Read(schema, impl, obj); }
public IValue ReadXML(XmlReaderImpl xmlReader, IValue valueType = null) { TypeTypeValue typeValue = null; if (valueType is TypeTypeValue typeTypeValue) { typeValue = typeTypeValue; } else if (xmlReader.NodeType == xmlNodeEnum.FromNativeValue(XmlNodeType.Element)) { IValue xsiType = xmlReader.GetAttribute(ValueFactory.Create("type"), XmlSchema.InstanceNamespace); IValue xsiNil = xmlReader.GetAttribute(ValueFactory.Create("nil"), XmlSchema.InstanceNamespace); if (xsiType.DataType == DataType.String) { switch (xsiType.AsString()) { case "string": typeValue = new TypeTypeValue("String"); break; case "decimal": typeValue = new TypeTypeValue("Number"); break; case "boolean": typeValue = new TypeTypeValue("Boolean"); break; case "dateTime": typeValue = new TypeTypeValue("Date"); break; default: break; } } else if (xsiNil.DataType == DataType.String) { typeValue = new TypeTypeValue("Undefined"); } } ; if (typeValue == null) { throw RuntimeException.InvalidArgumentValue(); } Type implType = TypeManager.GetImplementingClass(typeValue.Value.ID); IValue result = ValueFactory.Create(); if (typeValue.Equals(new TypeTypeValue("Undefined"))) { result = ValueFactory.Create(); xmlReader.Skip(); } else if (implType == typeof(DataType)) { xmlReader.Read(); if (xmlReader.NodeType == xmlNodeEnum.FromNativeValue(XmlNodeType.Text)) { result = XMLValue(typeValue, xmlReader.Value); xmlReader.Read(); } else { throw RuntimeException.InvalidArgumentValue(); } } else if (typeof(IXDTOSerializableXML).IsAssignableFrom(implType)) { result = Activator.CreateInstance(implType, new object[] { xmlReader, this }) as IValue; } xmlReader.Read(); return(result); }