private IXmlTemplateNode MoveToProperty(XmlReader reader, IEnumerator <IPropertyMap> properties, IXmlTemplateNode templateNode, XRoadMessage message, bool validateRequired)
{
IPropertyMap propertyMap = null;
while (properties.MoveNext())
{
propertyMap = properties.Current;
var propertyName = propertyMap.Definition.GetSerializedName();
var propertyNode = templateNode[properties.Current.Definition.TemplateName, message.Version];
if (reader.LocalName == propertyName)
{
return(propertyNode);
}
if (!propertyMap.Definition.IsOptional)
{
throw XRoadException.UnexpectedElementInQuery(Definition.Name, propertyName, reader.LocalName);
}
if (validateRequired && propertyNode != null && propertyNode.IsRequired)
{
throw XRoadException.MissingRequiredPropertyValues(Enumerable.Repeat(propertyName, 1));
}
}
if (propertyMap == null)
{
throw XRoadException.InvalidQuery($"Element `{reader.LocalName}` was unexpected at given location while deserializing type `{Definition.Name}`.");
}
else
{
throw XRoadException.UnexpectedElementInQuery(Definition.Name, propertyMap.Definition.GetSerializedName(), reader.LocalName);
}
}
/// <inheritdoc />
public object DeserializeResponse(XmlReader reader, XRoadMessage message)
{
var requestName = ResponseDefinition.RequestElementName;
var responseName = ResponseDefinition.ResponseElementName;
if (OperationDefinition.CopyRequestPartToResponse)
{
if (!reader.MoveToElement(3, requestName))
{
throw XRoadException.InvalidQuery($"Expected payload element `{requestName}` was not found in SOAP message.");
}
reader.Read();
}
var hasResponseElement = reader.MoveToElement(3);
if (hasResponseElement && !ResponseDefinition.ContainsNonTechnicalFault && reader.LocalName == ResponseDefinition.FaultName)
{
return(reader.ReadXRoadFault(4));
}
if (!hasResponseElement || reader.LocalName != responseName)
{
throw XRoadException.InvalidQuery($"Expected payload element `{responseName}` in SOAP message, but `{reader.LocalName}` was found instead.");
}
var hasWrapperElement = HasWrapperResultElement;
if (hasWrapperElement && !reader.MoveToElement(4, ResponseDefinition.Content.Name.LocalName, ResponseDefinition.Content.Name.NamespaceName))
{
throw XRoadException.InvalidQuery($"Expected result wrapper element `{ResponseDefinition.Content.Name}` was not found in SOAP message.");
}
return(ProcessResponseValue(DeserializeValue(reader, outputTypeMap, message.ResponseNode, ResponseDefinition.Content, message)));
}
public bool Deserialize(XmlReader reader, IXRoadSerializable dtoObject, IXmlTemplateNode templateNode, XRoadMessage message)
{
if (message.EnableFiltering && !filters.Contains(message.FilterName))
{
reader.ConsumeUnusedElement();
return(false);
}
string typeAttribute;
if (typeMap.Definition.IsAnonymous && !(typeMap is IArrayTypeMap) && (typeAttribute = reader.GetAttribute("type", NamespaceConstants.XSI)) != null)
{
throw XRoadException.InvalidQuery($"Expected anonymous type, but `{typeAttribute}` was given.");
}
var concreteTypeMap = (typeMap.Definition.IsInheritable ? serializer.GetTypeMapFromXsiType(reader) : null) ?? typeMap;
var propertyValue = concreteTypeMap.Deserialize(reader, templateNode, Definition.Content, message);
if (propertyValue == null)
{
return(true);
}
setValueMethod(dtoObject, propertyValue);
return(true);
}
private static Tuple <XName, bool> GetTypeAttributeValue(XmlReader reader, XName attributeName, bool isArrayType = false)
{
var typeValue = reader.GetAttribute(attributeName.LocalName, attributeName.NamespaceName);
if (typeValue == null)
{
return(null);
}
var namespaceSeparatorIndex = typeValue.IndexOf(':');
var namespacePrefix = namespaceSeparatorIndex < 0 ? string.Empty : typeValue.Substring(0, namespaceSeparatorIndex);
var typeName = namespaceSeparatorIndex < 0 ? typeValue : typeValue.Substring(namespaceSeparatorIndex + 1);
var typeNamespace = reader.LookupNamespace(namespacePrefix);
if (typeNamespace == null)
{
throw XRoadException.InvalidQuery($"Undefined namespace prefix `{namespacePrefix}` given in XML message for element `{reader.LocalName}` xsi:type.");
}
if (isArrayType)
{
typeName = typeName.Substring(0, typeName.LastIndexOf('['));
}
var qualifiedName = XName.Get(typeName, typeNamespace);
return(qualifiedName != qnSoapEncArray?Tuple.Create(qualifiedName, isArrayType) : GetTypeAttributeValue(reader, qnSoapEncArrayType, true));
}
/// <summary>
/// Deserializes X-Road message response or throws <see>XRoadFaultException</see> when
/// X-Road fault is parsed from the message instead of expected result value.
/// </summary>
public static object DeserializeMessageContent(this XRoadMessage message, IServiceMap serviceMap)
{
if (serviceMap.ResponseValueDefinition.ContainsNonTechnicalFault)
{
ThrowIfXRoadFault(message, serviceMap);
}
message.ContentStream.Position = 0;
using (var reader = XmlReader.Create(message.ContentStream))
{
reader.MoveToBody();
if (!reader.MoveToElement(2))
{
throw XRoadException.InvalidQuery("No payload element in SOAP message.");
}
if (reader.NamespaceURI == NamespaceConstants.SOAP_ENV && reader.LocalName == "Fault")
{
throw new SoapFaultException(SoapMessageHelper.DeserializeSoapFault(reader));
}
var result = serviceMap.DeserializeResponse(reader, message);
var fault = result as XRoadFault;
if (fault != null)
{
throw new XRoadFaultException(fault);
}
return(result);
}
}
private IXRoadProtocol ParseXRoadProtocol(XmlReader reader)
{
if (!reader.MoveToElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery("Päringus puudub SOAP-ENV:Envelope element.");
}
return(supportedProtocols.SingleOrDefault(p => p.IsDefinedByEnvelope(reader)));
}
private IServiceManager DetectServiceManager(XmlReader reader)
{
if (!reader.MoveToElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery("Päringus puudub SOAP-ENV:Envelope element.");
}
return(serviceManagers.SingleOrDefault(p => p.IsDefinedByEnvelope(reader)));
}
/// <summary>
/// Fast-forward XML reader position to payload element.
/// </summary>
public static void MoveToPayload(this XmlReader reader, XName rootElementName)
{
reader.MoveToBody();
if (!reader.MoveToElement(2, rootElementName.LocalName, rootElementName.NamespaceName))
{
throw XRoadException.InvalidQuery("Payload is missing from request content.");
}
}
private static XRoadClientIdentifier ReadClient(XmlReader reader)
{
var qualifiedName = reader.GetXName();
if (reader.IsEmptyElement)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` cannot be empty.");
}
var client = new XRoadClientIdentifier();
var depth = reader.Depth;
var objectType = reader.GetAttribute("objectType", NamespaceConstants.XROAD_V4_ID);
if (string.IsNullOrWhiteSpace(objectType))
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have attribute `{XName.Get("objectType", NamespaceConstants.XROAD_V4_ID)}` value.");
}
client.ObjectType = GetObjectType(objectType);
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "xRoadInstance" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID)}`.");
}
client.XRoadInstance = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "memberClass" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("memberClass", NamespaceConstants.XROAD_V4_ID)}`.");
}
client.MemberClass = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "memberCode" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("memberCode", NamespaceConstants.XROAD_V4_ID)}`.");
}
client.MemberCode = reader.ReadElementContentAsString();
var success = reader.MoveToElement(depth + 1);
if (success && reader.LocalName == "subsystemCode" && reader.NamespaceURI == NamespaceConstants.XROAD_V4_ID)
{
client.SubsystemCode = reader.ReadElementContentAsString();
success = reader.MoveToElement(depth + 1);
}
if (success)
{
throw XRoadException.InvalidQuery($"Unexpected element `{reader.GetXName()}` in element `{qualifiedName}`.");
}
return(client);
}
private void ValidateRemainingProperties(IEnumerator <IPropertyMap> properties, IContentDefinition contentDefinition)
{
while (properties.MoveNext())
{
if (!properties.Current.Definition.IsOptional)
{
var typeName = Definition?.Name ?? (((contentDefinition as ArrayItemDefinition)?.WrapperDefinition) as PropertyDefinition)?.DeclaringTypeDefinition?.Name;
throw XRoadException.InvalidQuery($"Element `{properties.Current.Definition.GetSerializedName()}` is required by type `{typeName}` definition.");
}
}
}
/// <summary>
/// Fast-forward XML reader position to SOAP Body element.
/// </summary>
public static void MoveToBody(this XmlReader reader)
{
if (!reader.MoveToElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery($"Element `{NamespaceConstants.SOAP}:Envelope` is missing from request content.");
}
if (!reader.MoveToElement(1, "Body", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery($"Element `{NamespaceConstants.SOAP}:Body` is missing from request content.");
}
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var contentID = reader.GetAttribute("href");
if (string.IsNullOrWhiteSpace(contentID))
{
if (message.IsMultipartContainer)
{
throw XRoadException.InvalidQuery("Missing `href` attribute to multipart content.");
}
var tempAttachment = new XRoadAttachment(new MemoryStream())
{
IsMultipartContent = false
};
message.AllAttachments.Add(tempAttachment);
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, tempAttachment.ContentStream));
}
reader.Read();
const int bufferSize = 1000;
int bytesRead;
var buffer = new byte[bufferSize];
while ((bytesRead = reader.ReadContentAsBase64(buffer, 0, bufferSize)) > 0)
{
tempAttachment.ContentStream.Write(buffer, 0, bytesRead);
}
return(tempAttachment.ContentStream);
}
var attachment = message.GetAttachment(contentID.Substring(4));
if (attachment == null)
{
throw XRoadException.PäringusPuudubAttachment(contentID);
}
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, attachment.ContentStream));
}
reader.ReadToEndElement();
return(attachment.ContentStream);
}
/// <inheritdoc />
public object DeserializeRequest(XmlReader reader, XRoadMessage message)
{
var requestName = RequestDefinition.RequestElementName;
if (!RequestDefinition.Content.MergeContent && !reader.MoveToElement(3, requestName))
{
throw XRoadException.InvalidQuery($"Päringus puudub X-tee `{requestName}` element.");
}
return(RequestDefinition.ParameterInfo != null
? ProcessRequestValue(DeserializeValue(reader, inputTypeMap, message.RequestNode, RequestDefinition.Content, message))
: null);
}
/// <summary>
/// Read next header value from the XML reader object.
/// </summary>
public virtual void ReadHeaderValue(XmlReader reader)
{
if (reader.NamespaceURI == NamespaceConstants.XROAD_V4_REPR && reader.LocalName == "representedParty")
{
RepresentedParty = ReadRepresentedParty(reader);
return;
}
if (reader.NamespaceURI == NamespaceConstants.XROAD_V4)
{
switch (reader.LocalName)
{
case "client":
Client = ReadClient(reader);
return;
case "service":
Service = ReadService(reader);
return;
case "centralService":
CentralService = ReadCentralService(reader);
return;
case "id":
Id = reader.ReadElementContentAsString();
return;
case "userId":
UserId = reader.ReadElementContentAsString();
return;
case "issue":
Issue = reader.ReadElementContentAsString();
return;
case "protocolVersion":
ProtocolVersion = reader.ReadElementContentAsString();
return;
case "requestHash":
RequestHash = ReadRequestHash(reader);
return;
}
}
throw XRoadException.InvalidQuery($"Unexpected X-Road header element `{reader.GetXName()}`.");
}
/// <summary>
/// Deserializes X-Road fault from message which is known to contain fault.
/// </summary>
public static IXRoadFault DeserializeXRoadFault(this IServiceMap serviceMap, XRoadMessage message)
{
message.ContentStream.Position = 0;
using (var reader = XmlReader.Create(message.ContentStream))
{
reader.MoveToPayload(message.RootElementName);
var responseName = serviceMap.ResponseValueDefinition.ResponseElementName;
if (!reader.MoveToElement(3, responseName))
{
throw XRoadException.InvalidQuery($"X-Road fault should be wrapped inside `{responseName}` element.");
}
return(reader.ReadXRoadFault(4));
}
}
private void ValidateRemainingProperties(ICollection <string> existingPropertyNames, ContentDefinition content)
{
if (existingPropertyNames.Count == requiredPropertiesCount.Value)
{
return;
}
var typeName = Definition?.Name ?? ((content.Particle as ArrayItemDefinition)?.Array as PropertyDefinition)?.DeclaringTypeDefinition?.Name;
var missingProperties = deserializationPropertyMaps.Where(kv => !existingPropertyNames.Contains(kv.Key) && !kv.Value.Definition.Content.IsOptional).Select(kv => $"`{kv.Key}`").ToList();
var propertyMessage = string.Join(", ", missingProperties);
var errorMessage = missingProperties.Count > 1
? $"Elements {propertyMessage} are required by type `{typeName}` definition."
: $"Element {propertyMessage} is required by type `{typeName}` definition.";
throw XRoadException.InvalidQuery(errorMessage);
}
/// <summary>
/// Check for presence of mandatory parts.
/// </summary>
public virtual void Validate()
{
if (Client == null)
{
throw XRoadException.InvalidQuery("X-Road header `client` element is mandatory.");
}
if (Id == null)
{
throw XRoadException.InvalidQuery("X-Road header `id` element is mandatory.");
}
if (ProtocolVersion == null)
{
throw XRoadException.InvalidQuery("X-Road header `protocolVersion` element is mandatory.");
}
}
private static XRoadObjectType GetObjectType(string value)
{
switch (value.Trim())
{
case "MEMBER":
return(XRoadObjectType.Member);
case "SUBSYSTEM":
return(XRoadObjectType.Subsystem);
case "SERVICE":
return(XRoadObjectType.Service);
case "CENTRALSERVICE":
return(XRoadObjectType.CentralService);
default:
throw XRoadException.InvalidQuery($"Invalid `{XName.Get("objectType", NamespaceConstants.XROAD_V4_ID)}` attribute value `{value}`.");
}
}
/// <summary>
/// Handle current X-Road operation.
/// </summary>
protected override void HandleRequest(XRoadContextClassic context)
{
if (context.HttpContext.Request.InputStream.Length == 0)
{
throw XRoadException.InvalidQuery("Empty request content");
}
context.Request.LoadRequest(context.HttpContext, StoragePath.GetValueOrDefault(Path.GetTempPath()), supportedProtocols);
if (context.Request.Protocol == null && context.Request.MetaServiceMap == null)
{
var supportedProtocolsString = string.Join(", ", supportedProtocols.Select(x => $@"""{x.Name}"""));
throw XRoadException.InvalidQuery($"Could not detect X-Road message protocol version from request message. Adapter supports following protocol versions: {supportedProtocolsString}.");
}
context.Response.Copy(context.Request);
context.ServiceMap = context.Request.MetaServiceMap;
OnRequestLoaded(context);
InvokeServiceMethod(context);
SerializeXRoadResponse(context);
}
private static XRoadCentralServiceIdentifier ReadCentralService(XmlReader reader)
{
var qualifiedName = reader.GetXName();
if (reader.IsEmptyElement)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` cannot be empty.");
}
var centralService = new XRoadCentralServiceIdentifier();
var depth = reader.Depth;
var objectType = reader.GetAttribute("objectType", NamespaceConstants.XROAD_V4_ID);
if (string.IsNullOrWhiteSpace(objectType))
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have attribute `{XName.Get("objectType", NamespaceConstants.XROAD_V4_ID)}` value.");
}
centralService.ObjectType = GetObjectType(objectType);
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "xRoadInstance" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID)}`.");
}
centralService.XRoadInstance = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "serviceCode" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("serviceCode", NamespaceConstants.XROAD_V4_ID)}`.");
}
centralService.ServiceCode = reader.ReadElementContentAsString();
if (reader.MoveToElement(depth + 1))
{
throw XRoadException.InvalidQuery($"Unexpected element `{reader.GetXName()}` in element `{qualifiedName}`.");
}
return(centralService);
}
/// <summary>
/// Reposition XML reader to the next element if it's currently at nil element.
/// </summary>
public static void ConsumeNilElement(this XmlReader reader, bool isNil)
{
if (!isNil)
{
return;
}
if (reader.IsEmptyElement)
{
reader.Read();
return;
}
var content = reader.ReadElementContentAsString();
if (!string.IsNullOrEmpty(content))
{
throw XRoadException.InvalidQuery($@"An element labeled with `xsi:nil=""true""` must be empty, but had `{content}` as content.");
}
reader.ReadToEndElement();
}
public static ISoapFault DeserializeSoapFault(XmlReader reader)
{
const int depth = 3;
var fault = new SoapFault();
if (reader.IsEmptyElement || !reader.MoveToElement(depth, "faultcode"))
{
throw XRoadException.InvalidQuery("SOAP Fault must have `faultcode` element.");
}
fault.FaultCode = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth, "faultstring"))
{
throw XRoadException.InvalidQuery("SOAP Fault must have `faultstring` element.");
}
fault.FaultString = reader.ReadElementContentAsString();
var success = reader.MoveToElement(depth);
if (success && reader.LocalName == "faultactor" && reader.NamespaceURI == "")
{
fault.FaultActor = reader.ReadElementContentAsString();
success = reader.MoveToElement(depth);
}
if (success && reader.LocalName == "detail" && reader.NamespaceURI == "")
{
fault.Details = reader.ReadInnerXml();
success = reader.MoveToElement(depth);
}
if (success)
{
throw XRoadException.InvalidQuery($"Unexpected element `{reader.GetXName()}` in SOAP Fault element.");
}
return(fault);
}
public object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
if (!reader.ReadToDescendant("Include", NamespaceConstants.XOP))
{
throw XRoadException.InvalidQuery("Missing `xop:Include` reference to multipart content.");
}
var contentID = reader.GetAttribute("href");
if (string.IsNullOrWhiteSpace(contentID))
{
throw XRoadException.InvalidQuery("Missing `href` attribute to multipart content.");
}
var attachment = message.GetAttachment(contentID.Substring(4));
if (attachment == null)
{
throw XRoadException.PäringusPuudubAttachment(contentID);
}
return(attachment.ContentStream);
}
private object DeserializeValue(XmlReader reader, ITypeMap typeMap, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
if (reader.IsNilElement())
{
reader.ReadToEndElement();
return(null);
}
string typeAttribute;
if (typeMap.Definition.IsAnonymous && !(typeMap is IArrayTypeMap) && (typeAttribute = reader.GetAttribute("type", NamespaceConstants.XSI)) != null)
{
throw XRoadException.InvalidQuery($"Expected anonymous type, but `{typeAttribute}` was given.");
}
var concreteTypeMap = typeMap;
if (!content.IgnoreExplicitType)
{
concreteTypeMap = (typeMap.Definition.IsInheritable ? serializer.GetTypeMapFromXsiType(reader) : null) ?? typeMap;
}
return(concreteTypeMap.Deserialize(reader, templateNode, content, message));
}
private static XRoadRepresentedParty ReadRepresentedParty(XmlReader reader)
{
var qualifiedName = reader.GetXName();
if (reader.IsEmptyElement)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` cannot be empty.");
}
var representedParty = new XRoadRepresentedParty();
var depth = reader.Depth;
var success = reader.MoveToElement(depth + 1);
if (success && reader.LocalName == "partyClass" && reader.NamespaceURI == NamespaceConstants.XROAD_V4_REPR)
{
representedParty.Class = reader.ReadElementContentAsString();
success = reader.MoveToElement(depth + 1);
}
if (!success)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("partyCode", NamespaceConstants.XROAD_V4_REPR)}`.");
}
if (reader.LocalName == "partyCode" && reader.NamespaceURI == NamespaceConstants.XROAD_V4_REPR)
{
representedParty.Code = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1))
{
return(representedParty);
}
}
throw XRoadException.InvalidQuery($"Unexpected element `{reader.GetXName()}` in element `{qualifiedName}`.");
}
/// <summary>
/// Handle incoming web request as X-Road service request.
/// </summary>
public override void HandleRequest(HttpContext httpContext)
{
using (var context = new XRoadContext(httpContext))
{
if (httpContext.Request.Body.CanSeek && httpContext.Request.Body.Length == 0)
{
throw XRoadException.InvalidQuery("Empty request content");
}
context.Request.LoadRequest(httpContext, storagePath, serviceManagers);
if (context.Request.ServiceManager == null && context.Request.MetaServiceMap == null)
{
var supportedProtocolsString = string.Join(", ", serviceManagers.Select(x => $@"""{x.Name}"""));
throw XRoadException.InvalidQuery($"Could not detect X-Road message protocol version from request message. Adapter supports following protocol versions: {supportedProtocolsString}.");
}
context.Response.Copy(context.Request);
context.ServiceMap = context.Request.MetaServiceMap;
OnRequestLoaded(context);
InvokeServiceMethod(context);
SerializeXRoadResponse(context);
}
}
/// <summary>
/// Try to read current position in XML reader as X-Road header element.
/// </summary>
public virtual void ReadHeaderValue(XmlReader reader)
{
if (reader.NamespaceURI == NamespaceConstants.XTEE)
{
switch (reader.LocalName)
{
case "autentija":
Autentija = reader.ReadElementContentAsString();
return;
case "ametniknimi":
AmetnikNimi = reader.ReadElementContentAsString();
return;
case "amet":
Amet = reader.ReadElementContentAsString();
return;
case "allasutus":
Allasutus = reader.ReadElementContentAsString();
return;
case "toimik":
Toimik = reader.ReadElementContentAsString();
return;
case "nimi":
Nimi = reader.ReadElementContentAsString();
return;
case "id":
Id = reader.ReadElementContentAsString();
return;
case "isikukood":
Isikukood = reader.ReadElementContentAsString();
return;
case "andmekogu":
Andmekogu = reader.ReadElementContentAsString();
return;
case "asutus":
Asutus = reader.ReadElementContentAsString();
return;
case "ametnik":
Ametnik = reader.ReadElementContentAsString();
return;
case "asynkroonne":
var value = reader.ReadElementContentAsString();
Asünkroonne = !string.IsNullOrWhiteSpace(value) && XmlConvert.ToBoolean(value);
return;
case "makstud":
Makstud = reader.ReadElementContentAsString();
return;
case "salastada":
Salastada = reader.ReadElementContentAsString();
return;
case "salastada_sertifikaadiga":
SalastadaSertifikaadiga = reader.ReadElementContentAsString();
return;
case "salastatud":
Salastatud = reader.ReadElementContentAsString();
return;
case "salastatud_sertifikaadiga":
SalastatudSertifikaadiga = reader.ReadElementContentAsString();
return;
}
}
throw XRoadException.InvalidQuery($"Unexpected X-Road header element `{reader.GetXName()}`.");
}
/// <summary>
/// Try to read current position in XML reader as X-Road header element.
/// </summary>
public virtual void ReadHeaderValue(XmlReader reader)
{
if (reader.NamespaceURI == NamespaceConstants.XROAD)
{
switch (reader.LocalName)
{
case "authenticator":
Authenticator = reader.ReadElementContentAsString();
return;
case "userName":
UserName = reader.ReadElementContentAsString();
return;
case "position":
Position = reader.ReadElementContentAsString();
return;
case "unit":
Unit = reader.ReadElementContentAsString();
return;
case "issue":
Issue = reader.ReadElementContentAsString();
return;
case "service":
ServiceName = reader.ReadElementContentAsString();
return;
case "id":
Id = reader.ReadElementContentAsString();
return;
case "userId":
UserId = reader.ReadElementContentAsString();
return;
case "producer":
Producer = reader.ReadElementContentAsString();
return;
case "consumer":
Consumer = reader.ReadElementContentAsString();
return;
case "async":
var value = reader.ReadElementContentAsString();
Async = !string.IsNullOrWhiteSpace(value) && XmlConvert.ToBoolean(value);
return;
case "paid":
Paid = reader.ReadElementContentAsString();
return;
case "encrypt":
Encrypt = reader.ReadElementContentAsString();
return;
case "encryptCert":
EncryptCert = reader.ReadElementContentAsString();
return;
case "encrypted":
Encrypted = reader.ReadElementContentAsString();
return;
case "encryptedCert":
EncryptedCert = reader.ReadElementContentAsString();
return;
}
}
throw XRoadException.InvalidQuery($"Unexpected X-Road header element `{reader.GetXName()}`.");
}
public void Read(XRoadMessage target, bool isResponse = false)
{
if (stream.CanSeek && stream.Length == 0)
{
return;
}
if (stream.CanSeek)
{
stream.Position = 0;
}
streamPosition = 0;
target.ContentEncoding = GetContentEncoding();
target.ContentStream = new MemoryStream();
target.IsMultipartContainer = ReadMessageParts(target);
target.ContentStream.Position = 0;
using (var reader = XmlReader.Create(target.ContentStream, new XmlReaderSettings {
CloseInput = false
}))
{
var protocol = ParseXRoadProtocol(reader);
ParseXRoadHeader(target, reader, protocol);
target.RootElementName = ParseMessageRootElementName(reader);
if (target.Protocol == null && target.RootElementName != null)
{
target.Protocol = supportedProtocols.SingleOrDefault(p => p.IsHeaderNamespace(target.RootElementName.NamespaceName));
}
target.MetaServiceMap = GetMetaServiceMap(target.RootElementName);
}
var xrh4 = target.Header as IXRoadHeader40;
if (xrh4 != null && xrh4.ProtocolVersion?.Trim() != "4.0")
{
throw XRoadException.InvalidQuery($"Unsupported X-Road v6 protocol version value `{xrh4.ProtocolVersion ?? string.Empty}`.");
}
if (target.IsMultipartContainer)
{
target.BinaryMode = BinaryMode.Attachment;
}
if (XRoadMessage.MULTIPART_CONTENT_TYPE_XOP.Equals(target.MultipartContentType))
{
target.BinaryMode = BinaryMode.Xml;
}
if (isResponse)
{
return;
}
if (target.RootElementName == null || string.IsNullOrWhiteSpace(target.Header?.Service?.ServiceCode))
{
return;
}
if (!Equals(target.RootElementName.LocalName, target.Header.Service.ServiceCode))
{
throw XRoadException.InvalidQuery($"Teenuse nimi `{target.Header.Service.ServiceCode}` ei ole vastavuses päringu sisuga `{target.RootElementName}`.");
}
}
