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;
}
