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}`."); } }