private void ParseXRoadHeader(XRoadMessage target, XmlReader reader, IXRoadProtocol protocol) { if (!reader.MoveToElement(1) || !reader.IsCurrentElement(1, "Header", NamespaceConstants.SOAP_ENV)) { return; } var header = protocol?.HeaderDefinition.CreateInstance(); var unresolved = new List <XElement>(); while (reader.MoveToElement(2)) { if (protocol == null) { protocol = supportedProtocols.SingleOrDefault(p => p.IsHeaderNamespace(reader.NamespaceURI)); header = protocol?.HeaderDefinition.CreateInstance(); } if (protocol == null || header == null || !protocol.IsHeaderNamespace(reader.NamespaceURI)) { unresolved.Add((XElement)XNode.ReadFrom(reader)); continue; } header.ReadHeaderValue(reader); } header?.Validate(); target.Header = header; target.UnresolvedHeaders = unresolved; target.Protocol = protocol; }
/// <summary> /// Serializes X-Road message SOAP headers to XML. /// </summary> public virtual void WriteTo(XmlWriter writer, IXRoadProtocol protocol) { if (writer.LookupPrefix(NamespaceConstants.XROAD) == null) { writer.WriteAttributeString("xmlns", PrefixConstants.XROAD, NamespaceConstants.XMLNS, NamespaceConstants.XROAD); } Action <string, object, XName> writeHeaderValue = (elementName, value, typeName) => { var name = XName.Get(elementName, NamespaceConstants.XROAD); if (protocol.HeaderDefinition.RequiredHeaders.Contains(name) || value != null) { protocol.Style.WriteHeaderElement(writer, name, value, typeName); } }; writeHeaderValue("consumer", Consumer, XmlTypeConstants.String); writeHeaderValue("producer", Producer, XmlTypeConstants.String); writeHeaderValue("userId", UserId, XmlTypeConstants.String); writeHeaderValue("issue", Issue, XmlTypeConstants.String); writeHeaderValue("service", ServiceName, XmlTypeConstants.String); writeHeaderValue("id", Id, XmlTypeConstants.String); writeHeaderValue("unit", Unit, XmlTypeConstants.String); writeHeaderValue("position", Position, XmlTypeConstants.String); writeHeaderValue("userName", UserName, XmlTypeConstants.String); writeHeaderValue("async", Async, XmlTypeConstants.Boolean); writeHeaderValue("authenticator", Authenticator, XmlTypeConstants.String); writeHeaderValue("paid", Paid, XmlTypeConstants.String); writeHeaderValue("encrypt", Encrypt, XmlTypeConstants.String); writeHeaderValue("encryptCert", EncryptCert, XmlTypeConstants.Base64); writeHeaderValue("encrypted", Encrypted, XmlTypeConstants.String); writeHeaderValue("encryptedCert", EncryptedCert, XmlTypeConstants.String); }
/// <summary> /// Serializes X-Road message SOAP headers to XML. /// </summary> public virtual void WriteTo(XmlWriter writer, IXRoadProtocol protocol) { if (writer.LookupPrefix(NamespaceConstants.XTEE) == null) { writer.WriteAttributeString("xmlns", PrefixConstants.XTEE, NamespaceConstants.XMLNS, NamespaceConstants.XTEE); } Action <string, object, XName> writeHeaderValue = (elementName, value, typeName) => { var name = XName.Get(elementName, NamespaceConstants.XTEE); if (protocol.HeaderDefinition.RequiredHeaders.Contains(name) || value != null) { protocol.Style.WriteHeaderElement(writer, name, value, typeName); } }; writeHeaderValue("asutus", Asutus, XmlTypeConstants.String); writeHeaderValue("andmekogu", Andmekogu, XmlTypeConstants.String); writeHeaderValue("isikukood", Isikukood, XmlTypeConstants.String); writeHeaderValue("toimik", Toimik, XmlTypeConstants.String); writeHeaderValue("nimi", Nimi, XmlTypeConstants.String); writeHeaderValue("ametnik", Ametnik, XmlTypeConstants.String); writeHeaderValue("id", Id, XmlTypeConstants.String); writeHeaderValue("allasutus", Allasutus, XmlTypeConstants.String); writeHeaderValue("amet", Amet, XmlTypeConstants.String); writeHeaderValue("ametniknimi", AmetnikNimi, XmlTypeConstants.String); writeHeaderValue("asynkroonne", Asünkroonne, XmlTypeConstants.Boolean); writeHeaderValue("autentija", Autentija, XmlTypeConstants.String); writeHeaderValue("makstud", Makstud, XmlTypeConstants.String); writeHeaderValue("salastada", Salastada, XmlTypeConstants.String); writeHeaderValue("salastada_sertifikaadiga", SalastadaSertifikaadiga, XmlTypeConstants.Base64); writeHeaderValue("salastatud", Salastatud, XmlTypeConstants.String); writeHeaderValue("salastatud_sertifikaadiga", SalastatudSertifikaadiga, XmlTypeConstants.String); }
// public IEnumerable<string> AvailableFilters { get { return availableFilters; } set { availableFilters = value != null ? new List<string>(value) : null; } } public SerializerCache(IXRoadProtocol protocol, SchemaDefinitionProvider schemaDefinitionProvider, uint?version = null) { this.schemaDefinitionProvider = schemaDefinitionProvider; availableFilters = schemaDefinitionProvider.ProtocolDefinition.EnabledFilters; contractAssembly = schemaDefinitionProvider.ProtocolDefinition.ContractAssembly; Protocol = protocol; Version = version; AddSystemType <DateTime>("dateTime", x => new DateTimeTypeMap(x)); AddSystemType <DateTime>("date", x => new DateTypeMap(x)); AddSystemType <bool>("boolean", x => new BooleanTypeMap(x)); AddSystemType <float>("float", x => new SingleTypeMap(x)); AddSystemType <double>("double", x => new DoubleTypeMap(x)); AddSystemType <decimal>("decimal", x => new DecimalTypeMap(x)); AddSystemType <long>("long", x => new Int64TypeMap(x)); AddSystemType <int>("int", x => new Int32TypeMap(x)); AddSystemType <short>("short", x => new Int16TypeMap(x)); AddSystemType <BigInteger>("integer", x => new IntegerTypeMap(x)); AddSystemType <string>("string", x => new StringTypeMap(x)); AddSystemType <string>("anyURI", x => new StringTypeMap(x)); AddSystemType <Stream>("base64Binary", x => new ContentTypeMap(x)); AddSystemType <Stream>("hexBinary", x => new ContentTypeMap(x)); AddSystemType <Stream>("base64", x => new ContentTypeMap(x)); }
/// <summary> /// Initialize new handler for certain protocol. /// </summary> public XRoadWsdlHandler(IXRoadProtocol protocol) { if (protocol == null) { throw new ArgumentNullException(nameof(protocol)); } this.protocol = protocol; }
private XDocument GetDocument(IXRoadProtocol protocol, uint version) { using (var stream = new MemoryStream()) { protocol.WriteServiceDescription(stream, version); stream.Position = 0; return(XDocument.Load(stream)); } }
private static void SerializeFault(XmlWriter writer, IXRoadFault fault, IXRoadProtocol protocol) { writer.WriteStartElement("faultCode"); protocol.Style.WriteExplicitType(writer, XName.Get("string", NamespaceConstants.XSD)); writer.WriteValue(fault.FaultCode); writer.WriteEndElement(); writer.WriteStartElement("faultString"); protocol.Style.WriteExplicitType(writer, XName.Get("string", NamespaceConstants.XSD)); writer.WriteValue(fault.FaultString); writer.WriteEndElement(); }
/// <summary> /// Serializes header of SOAP message. /// </summary> public static void WriteSoapHeader(this IXRoadProtocol protocol, XmlWriter writer, IXRoadHeader header, IEnumerable <XElement> additionalHeaders = null) { writer.WriteStartElement("Header", NamespaceConstants.SOAP_ENV); header?.WriteTo(writer, protocol); foreach (var additionalHeader in additionalHeaders ?? Enumerable.Empty <XElement>()) { additionalHeader.WriteTo(writer); } writer.WriteEndElement(); }
private object DeserializeRequest(string templateXml, string contentXml, IXRoadProtocol protocol, Func <XRoadMessageReader, XmlReader, object> deserializeMessage) { using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { writer.WriteLine(@"<?xml version=""1.0"" encoding=""utf-8""?>"); writer.WriteLine($"<soapenv:Envelope xmlns:soapenv=\"{NamespaceConstants.SOAP_ENV}\" soapenv:encodingStyle=\"{NamespaceConstants.SOAP_ENC}\">"); writer.WriteLine(@"<soapenv:Body>"); writer.WriteLine($"<tns:Service1 xmlns:tns=\"{protocol.ProducerNamespace}\">"); writer.WriteLine(contentXml); writer.WriteLine("@</tns:Service1>"); writer.WriteLine("@</soapenv:Body>"); writer.WriteLine("@</soapenv:Envelope>"); writer.Flush(); stream.Position = 0; using (var reader = XmlReader.Create(stream)) using (var messageReader = new XRoadMessageReader(stream, "text/xml; charset=UTF-8", null, new[] { protocol })) return(deserializeMessage(messageReader, reader)); } }
/// <summary> /// Initialize new X-Road message of this X-Road message protocol instance. /// </summary> public static XRoadMessage CreateMessage(this IXRoadProtocol protocol, IXRoadHeader header = null) => new XRoadMessage(protocol, header ?? protocol.HeaderDefinition.CreateInstance());
/// <summary> /// Serializes X-Road message SOAP headers to XML. /// </summary> public virtual void WriteTo(XmlWriter writer, IXRoadProtocol protocol) { if (writer.LookupPrefix(NamespaceConstants.XROAD_V4) == null) { writer.WriteAttributeString("xmlns", PrefixConstants.XROAD, NamespaceConstants.XMLNS, NamespaceConstants.XROAD_V4); } if (writer.LookupPrefix(NamespaceConstants.XROAD_V4_ID) == null) { writer.WriteAttributeString("xmlns", PrefixConstants.ID, NamespaceConstants.XMLNS, NamespaceConstants.XROAD_V4_ID); } if (protocol.HeaderDefinition.RequiredHeaders.Contains(XName.Get("client", NamespaceConstants.XROAD_V4)) || Client != null) { var element = new XElement(XName.Get("client", NamespaceConstants.XROAD_V4), new XAttribute(XName.Get("objectType", NamespaceConstants.XROAD_V4_ID), string.IsNullOrWhiteSpace(Client.SubsystemCode) ? "MEMBER" : "SUBSYSTEM"), new XElement(XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID), Client.XRoadInstance), new XElement(XName.Get("memberClass", NamespaceConstants.XROAD_V4_ID), Client.MemberClass), new XElement(XName.Get("memberCode", NamespaceConstants.XROAD_V4_ID), Client.MemberCode)); if (!string.IsNullOrWhiteSpace(Client.SubsystemCode)) { element.Add(new XElement(XName.Get("subsystemCode", NamespaceConstants.XROAD_V4_ID), Client.SubsystemCode)); } element.WriteTo(writer); } if (protocol.HeaderDefinition.RequiredHeaders.Contains(XName.Get("service", NamespaceConstants.XROAD_V4)) || Service != null) { var element = new XElement(XName.Get("service", NamespaceConstants.XROAD_V4), new XAttribute(XName.Get("objectType", NamespaceConstants.XROAD_V4_ID), "SERVICE"), new XElement(XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID), Service.XRoadInstance), new XElement(XName.Get("memberClass", NamespaceConstants.XROAD_V4_ID), Service.MemberClass), new XElement(XName.Get("memberCode", NamespaceConstants.XROAD_V4_ID), Service.MemberCode)); if (!string.IsNullOrWhiteSpace(Service.SubsystemCode)) { element.Add(new XElement(XName.Get("subsystemCode", NamespaceConstants.XROAD_V4_ID), Service.SubsystemCode)); } element.Add(new XElement(XName.Get("serviceCode", NamespaceConstants.XROAD_V4_ID), Service.ServiceCode)); if (!string.IsNullOrWhiteSpace(Service.ServiceVersion)) { element.Add(new XElement(XName.Get("serviceVersion", NamespaceConstants.XROAD_V4_ID), Service.ServiceVersion)); } element.WriteTo(writer); } if (protocol.HeaderDefinition.RequiredHeaders.Contains(XName.Get("centralService", NamespaceConstants.XROAD_V4)) || CentralService != null) { var element = new XElement(XName.Get("centralService", NamespaceConstants.XROAD_V4), new XAttribute(XName.Get("objectType", NamespaceConstants.XROAD_V4_ID), "CENTRALSERVICE"), new XElement(XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID), CentralService.XRoadInstance), new XElement(XName.Get("serviceCode", NamespaceConstants.XROAD_V4_ID), CentralService.ServiceCode)); element.WriteTo(writer); } Action <string, object, XName> writeHeaderValue = (elementName, value, typeName) => { var name = XName.Get(elementName, NamespaceConstants.XROAD_V4); if (protocol.HeaderDefinition.RequiredHeaders.Contains(name) || value != null) { protocol.Style.WriteHeaderElement(writer, name, value, typeName); } }; writeHeaderValue("id", Id, XmlTypeConstants.String); writeHeaderValue("userId", UserId, XmlTypeConstants.String); writeHeaderValue("issue", Issue, XmlTypeConstants.String); writeHeaderValue("protocolVersion", ProtocolVersion, XmlTypeConstants.String); }
/// <summary> /// Loads X-Road message contents from response message. /// </summary> public void LoadResponse(Stream stream, string contentTypeHeader, string storagePath, IXRoadProtocol protocol) { LoadResponse(stream, contentTypeHeader, storagePath, new [] { protocol }); }
/// <summary> /// Initializes new empty X-Road message for request serialization. /// </summary> public XRoadMessage(IXRoadProtocol protocol, IXRoadHeader header) : this(new MemoryStream()) { Protocol = protocol; Header = header; }
/// <summary> /// Initialize builder with contract details. /// <param name="protocol">X-Road protocol to use when generating service description.</param> /// <param name="schemaDefinitionProvider">Provides overrides for default presentation format.</param> /// <param name="version">Global version for service description (when versioning entire schema and operations using same version number).</param> /// </summary> public ProducerDefinition(IXRoadProtocol protocol, SchemaDefinitionProvider schemaDefinitionProvider, uint?version = null) { if (protocol == null) { throw new ArgumentNullException(nameof(protocol)); } this.protocol = protocol; if (schemaDefinitionProvider == null) { throw new ArgumentNullException(nameof(schemaDefinitionProvider)); } this.schemaDefinitionProvider = schemaDefinitionProvider; this.version = version; contractAssembly = schemaDefinitionProvider.ProtocolDefinition.ContractAssembly; portType = new PortType { Name = "PortTypeName" }; binding = new Binding { Name = "BindingName", Type = new XmlQualifiedName(portType.Name, protocol.ProducerNamespace) }; servicePort = new Port { Name = "PortName", Binding = new XmlQualifiedName(binding.Name, protocol.ProducerNamespace) }; service = new Service { Name = "ServiceName", Ports = { servicePort } }; CollectTypes(); var globalNamespaces = new Dictionary <string, string>(); addGlobalNamespace = (namespaceName) => { var prefix = NamespaceConstants.GetPreferredPrefix(namespaceName); if (string.IsNullOrEmpty(prefix)) { return(false); } globalNamespaces[prefix] = namespaceName; return(true); }; getGlobalNamespaces = () => globalNamespaces.Select(x => Tuple.Create(x.Key, x.Value)).ToList(); var requiredImports = new SortedSet <Tuple <string, string> >(); addRequiredImport = (schemaNamespace, typeNamespace, schemaExporter) => { if (typeNamespace == NamespaceConstants.XSD || typeNamespace == schemaNamespace) { return; } if (!schemaLocations.ContainsKey(typeNamespace)) { schemaLocations.Add(typeNamespace, schemaDefinitionProvider.GetSchemaLocation(typeNamespace, schemaExporter)); } requiredImports.Add(Tuple.Create(schemaNamespace, typeNamespace)); }; getRequiredImports = ns => requiredImports.Where(x => x.Item1 == ns).Select(x => x.Item2).ToList(); xRoadPrefix = schemaDefinitionProvider.GetXRoadPrefix(); xRoadNamespace = schemaDefinitionProvider.GetXRoadNamespace(); headerDefinition = schemaDefinitionProvider.GetXRoadHeaderDefinition(); addGlobalNamespace(NamespaceConstants.SOAP); addGlobalNamespace(NamespaceConstants.WSDL); addGlobalNamespace(NamespaceConstants.XSD); }
/// <summary> /// Test if given namespace is defined as SOAP header element namespace. /// </summary> public static bool IsHeaderNamespace(this IXRoadProtocol protocol, string namespaceName) => protocol.HeaderDefinition.IsHeaderNamespace(namespaceName);
/// <summary> /// Check if envelope defines given protocol schema. /// </summary> public static bool IsDefinedByEnvelope(this IXRoadProtocol protocol, XmlReader reader) => protocol.ProtocolDefinition.DetectEnvelope?.Invoke(reader) ?? false;
/// <summary> /// Initialize new request object. /// <param name="uri">Network location of the adapter or X-Road server.</param> /// <param name="protocol">X-Road message protocol version.</param> /// <param name="requestNamespace">Overrides default producer namespace for operation payload element.</param> /// </summary> public XRoadRequest(Uri uri, IXRoadProtocol protocol, string requestNamespace = null) { Protocol = protocol; Uri = uri; RequestNamespace = requestNamespace; }