/// <summary>
/// Initialize new X-Road context instance.
/// </summary>
public WebServiceContext(HttpContext httpContext)
{
HttpContext = httpContext;
Request = new XRoadMessage();
Response = new XRoadMessage(new MemoryStream());
}
public void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, XRoadMessage message)
{
if (message.EnableFiltering && !filters.Contains(message.FilterName))
{
return;
}
var propertyValue = value != null?getValueMethod(value) : null;
if (Definition.Content.IsOptional && !Definition.Content.IsNullable && propertyValue == null)
{
return;
}
if (!Definition.Content.MergeContent)
{
writer.WriteStartElement(Definition.Content.Name);
if (propertyValue == null)
{
writer.WriteNilAttribute();
}
}
if (propertyValue != null)
{
var concreteTypeMap = typeMap.Definition.IsInheritable ? serializer.GetTypeMap(propertyValue.GetType()) : typeMap;
concreteTypeMap.Serialize(writer, templateNode, propertyValue, Definition.Content, message);
}
if (!Definition.Content.MergeContent)
{
writer.WriteEndElement();
}
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitType(writer, Definition.Name);
}
writer.WriteValue(value);
}
private static double?HandleEmptyElement(ContentDefinition content, XRoadMessage message)
{
return(message.HandleEmptyElementOfValueType <double>(content, () => throw new InvalidQueryException("'' is not a valid value for 'double'")));
}
private void SerializeValue(XmlWriter writer, object value, ITypeMap typeMap, IXmlTemplateNode templateNode, XRoadMessage message, ContentDefinition content)
{
if (value == null)
{
writer.WriteNilAttribute();
return;
}
var concreteTypeMap = typeMap.Definition.IsInheritable ? serializer.GetTypeMap(value.GetType()) : typeMap;
concreteTypeMap.Serialize(writer, templateNode, value, content, message);
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
var valueArray = (Array)value;
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitArrayType(writer, elementTypeMap.Definition.Name, valueArray.Length);
}
var arrayItemDefinition = definition.ArrayItemDefinition;
var itemName = arrayItemDefinition.Name.LocalName;
foreach (var valueItem in valueArray)
{
writer.WriteStartElement(itemName);
if (valueItem != null)
{
var typeMap = serializerCache != null?serializerCache.GetTypeMap(valueItem.GetType()) : elementTypeMap;
typeMap.Serialize(writer, templateNode, valueItem, arrayItemDefinition, message);
}
else
{
writer.WriteNilAttribute();
}
writer.WriteEndElement();
}
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, HandleEmptyElement(content, message)));
}
var value = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(value))
{
return(HandleEmptyElement(content, message));
}
return(XmlConvert.ToDouble(value));
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, Enum.ToObject(Definition.Type, 0)));
}
var stringValue = reader.ReadElementContentAsString();
int enumerationValue;
if (!deserializationMapping.TryGetValue(stringValue, out enumerationValue))
{
throw new MissingFieldException($"Unexpected value `{stringValue}` for enumeration type `{Definition.Name}`.");
}
return(Enum.ToObject(Definition.Type, enumerationValue));
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitType(writer, Definition.Name);
}
string enumerationValue;
if (!serializationMapping.TryGetValue((int)value, out enumerationValue))
{
throw new MissingFieldException($"Cannot map value `{value}` to enumeration type `{Definition.Name}`.");
}
writer.WriteValue(enumerationValue);
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
if (!(content.Particle is RequestDefinition))
{
message.Style.WriteExplicitType(writer, Definition.Name);
}
writer.WriteValue(value);
}
/// <summary>
/// Initialize event argument class.
/// </summary>
public XRoadRequestEventArgs(WebRequest webRequest, XRoadMessage message)
{
Message = message;
WebRequest = webRequest;
}
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 ? serializerCache.GetTypeMapFromXsiType(reader) : null) ?? typeMap;
var propertyValue = concreteTypeMap.Deserialize(reader, templateNode, Definition, message);
if (propertyValue == null)
{
return(true);
}
setValueMethod(dtoObject, propertyValue);
return(true);
}
/// <summary>
/// Serializes X-Road message protocol responses according to operation definitions.
/// </summary>
public void SerializeResponse(XmlWriter writer, object value, XRoadMessage message, XmlReader requestReader, ICustomSerialization customSerialization)
{
var containsRequest = requestReader.MoveToElement(2, OperationDefinition.Name.LocalName, OperationDefinition.Name.NamespaceName);
if (containsRequest)
{
writer.WriteStartElement(requestReader.Prefix, $"{OperationDefinition.Name.LocalName}Response", OperationDefinition.Name.NamespaceName);
}
else
{
writer.WriteStartElement($"{OperationDefinition.Name.LocalName}Response", OperationDefinition.Name.NamespaceName);
}
var fault = value as IXRoadFault;
var namespaceInContext = requestReader.NamespaceURI;
if (containsRequest && OperationDefinition.CopyRequestPartToResponse)
{
CopyRequestToResponse(writer, requestReader);
}
if (!ResponseValueDefinition.ContainsNonTechnicalFault && fault != null)
{
writer.WriteStartElement(ResponseValueDefinition.FaultName);
SerializeFault(writer, fault, message.Protocol);
writer.WriteEndElement();
}
else if (outputTypeMap != null)
{
if (Equals(namespaceInContext, ""))
{
writer.WriteStartElement(ResponseValueDefinition.ResponseElementName);
}
else
{
writer.WriteStartElement(ResponseValueDefinition.ResponseElementName, "");
}
if (fault != null)
{
SerializeFault(writer, fault, message.Protocol);
}
else if (outputTypeMap != null)
{
var addWrapperElement = HasWrapperResultElement;
if (addWrapperElement)
{
writer.WriteStartElement(ResponseValueDefinition.Name.LocalName, ResponseValueDefinition.Name.NamespaceName);
}
SerializeValue(writer, PrepareResponseValue(value), outputTypeMap, message.ResponseNode, message, ResponseValueDefinition);
if (addWrapperElement)
{
writer.WriteEndElement();
}
}
writer.WriteEndElement();
customSerialization?.OnContentComplete(writer);
}
writer.WriteEndElement();
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, 0));
}
var value = reader.ReadElementContentAsString();
return(string.IsNullOrEmpty(value) ? new BigInteger() : new BigInteger(XmlConvert.ToDecimal(value)));
}
private IXmlTemplateNode MoveToProperty(XmlReader reader, IEnumerator <IPropertyMap> properties, IXmlTemplateNode templateNode, XRoadMessage message, bool validateRequired)
{
IPropertyMap propertyMap = null;
while (properties.MoveNext())
{
propertyMap = properties.Current ?? throw new NullReferenceException();
var propertyName = propertyMap.Definition.Content.SerializedName;
var propertyNode = templateNode[properties.Current.Definition.TemplateName, message.Version];
if (reader.GetXName() == propertyName)
{
return(propertyNode);
}
if (!propertyMap.Definition.Content.IsOptional)
{
throw new UnexpectedElementException(Definition, propertyMap.Definition, reader.GetXName());
}
if (validateRequired && propertyNode != null && propertyNode.IsRequired)
{
throw new ParameterRequiredException(Definition, propertyMap.Definition);
}
}
if (propertyMap == null)
{
throw new InvalidQueryException($"Element `{reader.GetXName()}` was unexpected at given location while deserializing type `{Definition.Name}`.");
}
throw new UnexpectedElementException(Definition, propertyMap.Definition, reader.GetXName());
}
private static IEnumerable <string> GetMissingRequiredPropertyNames(IXRoadSerializable dtoObject, IXmlTemplateNode templateNode, XRoadMessage message)
{
return(templateNode.ChildNames
.Select(n => templateNode[n, message.Version])
.Where(n => n.IsRequired)
.Where(n => !dtoObject.IsSpecified(n.Name))
.Select(n => n.Name));
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, new T[0]));
}
var items = new List <T>();
var parentDepth = definition.MergeContent ? reader.Depth - 1 : reader.Depth;
var itemDepth = parentDepth + 1;
var itemName = definition.ArrayItemDefinition.Name.LocalName;
if (!definition.MergeContent)
{
reader.Read();
}
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
if (reader.LocalName != itemName)
{
if (definition.MergeContent)
{
break;
}
if (!definition.ArrayItemDefinition.AcceptAnyName)
{
throw new Exception($"Invalid array item name {reader.LocalName}.");
}
}
if (reader.IsNilElement())
{
items.Add(default(T));
reader.Read();
continue;
}
var typeMap = serializerCache.GetTypeMapFromXsiType(reader) ?? elementTypeMap;
var value = typeMap.Deserialize(reader, templateNode, definition.ArrayItemDefinition, message);
items.Add(value == null ? default(T) : (T)value);
}
return(items.ToArray());
}
private static bool ReadPropertyValue(XmlReader reader, IPropertyMap propertyMap, IXmlTemplateNode templateNode, XRoadMessage message, bool validateRequired, T dtoObject)
{
var templateName = propertyMap.Definition.TemplateName;
var propertyNode = templateNode[templateName, message.Version];
if (propertyNode == null)
{
reader.ConsumeUnusedElement();
return(false);
}
var isNull = reader.IsNilElement();
if (validateRequired && isNull && propertyNode.IsRequired)
{
throw XRoadException.MissingRequiredPropertyValues(Enumerable.Repeat(propertyMap.Definition.Name.LocalName, 1));
}
if ((isNull || propertyMap.Deserialize(reader, dtoObject, propertyNode, message)) && !string.IsNullOrWhiteSpace(templateName))
{
dtoObject.OnMemberDeserialized(templateName);
}
reader.ConsumeNilElement(isNull);
return(propertyNode.IsRequired);
}
/// <summary>
/// Initialize event argument class.
/// </summary>
public XRoadRequestEventArgs(XRoadMessage message)
{
Message = message;
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
message.Style.WriteType(writer, Definition, content.RuntimeType, content.Particle is RequestDefinition);
if (contentPropertyMap != null)
{
var childTemplateNode = templateNode?[contentPropertyMap.Definition.TemplateName, message.Version];
if (templateNode == null || childTemplateNode != null)
{
contentPropertyMap.Serialize(writer, childTemplateNode, value, message);
}
return;
}
foreach (var propertyMap in propertyMaps)
{
var childTemplateNode = templateNode?[propertyMap.Definition.TemplateName, message.Version];
if (templateNode == null || childTemplateNode != null)
{
propertyMap.Serialize(writer, childTemplateNode, value, message);
}
}
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
message.Style.WriteType(writer, Definition, content);
writer.WriteValue(value);
}
private IEnumerable <PropertyDefinition> GetMissingRequiredProperties(IXRoadSerializable dtoObject, IXmlTemplateNode templateNode, XRoadMessage message)
{
return(templateNode.ChildNames
.Select(n => templateNode[n, message.Version])
.Where(n => n.IsRequired)
.Where(n => !dtoObject.IsSpecified(n.Name))
.Select(n => deserializationPropertyMaps[n.Name].Definition));
}
private object DeserializeValue(XmlReader reader, ITypeMap typeMap, IXmlTemplateNode templateNode, ParticleDefinition particleDefinition, XRoadMessage message)
{
if (reader.IsNilElement())
{
reader.ReadToEndElement();
return(null);
}
XName typeAttribute;
if (typeMap.Definition.IsAnonymous && !(typeMap is IArrayTypeMap) && (typeAttribute = reader.GetTypeAttributeValue()) != null)
{
throw new UnknownTypeException($"Expected anonymous type, but `{typeAttribute}` was given.", particleDefinition, typeMap.Definition, typeAttribute);
}
var concreteTypeMap = typeMap;
if (!particleDefinition.Content.IgnoreExplicitType)
{
concreteTypeMap = (typeMap.Definition.IsInheritable ? serializer.GetTypeMapFromXsiType(reader, particleDefinition) : null) ?? typeMap;
}
return(concreteTypeMap.Deserialize(reader, templateNode, particleDefinition.Content, message));
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var dtoObject = new T();
dtoObject.SetTemplateMembers(templateNode.ChildNames);
var validateRequired = content.Particle is RequestDefinition;
if (contentPropertyMap != null)
{
ReadPropertyValue(reader, contentPropertyMap, templateNode, message, validateRequired, dtoObject);
return(dtoObject);
}
var existingPropertyNames = new HashSet <XName>();
if (reader.IsEmptyElement)
{
ValidateRemainingProperties(existingPropertyNames, content);
return(MoveNextAndReturn(reader, dtoObject));
}
var parentDepth = reader.Depth;
var itemDepth = parentDepth + 1;
var requiredCount = 0;
reader.Read();
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
var propertyMap = GetPropertyMap(reader);
if (!propertyMap.Definition.Content.IsOptional)
{
existingPropertyNames.Add(reader.GetXName());
}
if (ReadPropertyValue(reader, propertyMap, templateNode, message, validateRequired, dtoObject) && validateRequired)
{
requiredCount++;
}
}
if (validateRequired && requiredCount < templateNode.CountRequiredNodes(message.Version))
{
var properties = GetMissingRequiredProperties(dtoObject, templateNode, message).ToList();
throw new ParameterRequiredException(Definition, properties);
}
ValidateRemainingProperties(existingPropertyNames, content);
return(dtoObject);
}
public bool Deserialize(XmlReader reader, IXRoadSerializable dtoObject, IXmlTemplateNode templateNode, XRoadMessage message)
{
if (message.EnableFiltering && !filters.Contains(message.FilterName))
{
reader.ConsumeUnusedElement();
return(false);
}
XName typeAttribute;
if (typeMap.Definition.IsAnonymous && !(typeMap is IArrayTypeMap) && (typeAttribute = reader.GetTypeAttributeValue()) != null)
{
throw new UnknownTypeException($"Expected anonymous type, but `{typeAttribute}` was given.", Definition, typeMap.Definition, typeAttribute);
}
var concreteTypeMap = (typeMap.Definition.IsInheritable ? serializer.GetTypeMapFromXsiType(reader, Definition) : null) ?? typeMap;
var propertyValue = concreteTypeMap.Deserialize(reader, templateNode, Definition.Content, message);
if (propertyValue == null)
{
return(true);
}
setValueMethod(dtoObject, propertyValue);
return(true);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var entity = new T();
entity.SetTemplateMembers(templateNode.ChildNames);
var validateRequired = content.Particle is RequestDefinition;
if (contentPropertyMap != null)
{
ReadPropertyValue(reader, contentPropertyMap, templateNode[contentPropertyMap.Definition.TemplateName, message.Version], message, validateRequired, entity);
return(entity);
}
var properties = propertyMaps.GetEnumerator();
if (reader.IsEmptyElement)
{
ValidateRemainingProperties(properties, content);
return(MoveNextAndReturn(reader, entity));
}
var parentDepth = reader.Depth;
var itemDepth = parentDepth + 1;
reader.Read();
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
var propertyNode = MoveToProperty(reader, properties, templateNode, message, validateRequired);
ReadPropertyValue(reader, properties.Current, propertyNode, message, validateRequired, entity);
}
ValidateRemainingProperties(properties, content);
return(entity);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, 0.0));
}
var value = reader.ReadElementContentAsString();
return(string.IsNullOrEmpty(value) ? 0.0 : XmlConvert.ToDouble(value));
}
private void ReadPropertyValue(XmlReader reader, IPropertyMap propertyMap, IXmlTemplateNode propertyNode, XRoadMessage message, bool validateRequired, T dtoObject)
{
if (propertyNode == null)
{
reader.ConsumeUnusedElement();
return;
}
var isNull = reader.IsNilElement();
if (validateRequired && isNull && propertyNode.IsRequired)
{
throw new ParameterRequiredException(Definition, propertyMap.Definition);
}
var templateName = propertyMap.Definition.TemplateName;
if ((isNull || propertyMap.Deserialize(reader, dtoObject, propertyNode, message)) && !string.IsNullOrWhiteSpace(templateName))
{
dtoObject.OnMemberDeserialized(templateName);
}
reader.ConsumeNilElement(isNull);
}
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));
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
var valueArray = (Array)value;
if (!(content.Particle is RequestDefinition))
{
message.Style.WriteExplicitArrayType(writer, elementTypeMap.Definition.Name, valueArray.Length);
}
var arrayContent = (ArrayContentDefiniton)content;
var itemName = arrayContent.Item.Content.Name.LocalName;
foreach (var valueItem in valueArray)
{
writer.WriteStartElement(itemName);
if (valueItem != null)
{
var typeMap = serializer != null?serializer.GetTypeMap(valueItem.GetType()) : elementTypeMap;
typeMap.Serialize(writer, templateNode, valueItem, arrayContent.Item.Content, message);
}
else
{
writer.WriteNilAttribute();
}
writer.WriteEndElement();
}
}
