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 void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
var attachment = new XRoadAttachment((Stream)value);
message.AllAttachments.Add(attachment);
if (message.BinaryMode == BinaryMode.Attachment)
{
if (!(content.Particle is RequestDefinition))
{
message.Style.WriteExplicitType(writer, encodedTypeName);
}
writer.WriteAttributeString("href", $"cid:{attachment.ContentID}");
return;
}
if (!(content.Particle is RequestDefinition))
{
message.Style.WriteExplicitType(writer, Definition.Name);
}
attachment.IsMultipartContent = false;
attachment.WriteAsBase64(writer);
}
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);
}
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();
}
}
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 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);
}
private 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 new ParameterRequiredException(Definition, propertyMap.Definition);
}
if ((isNull || propertyMap.Deserialize(reader, dtoObject, propertyNode, message)) && !string.IsNullOrWhiteSpace(templateName))
{
dtoObject.OnMemberDeserialized(templateName);
}
reader.ConsumeNilElement(isNull);
return(propertyNode.IsRequired);
}
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 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 override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var arrayContent = (ArrayContentDefiniton)content;
if (reader.IsEmptyElement && !arrayContent.MergeContent)
{
return(MoveNextAndReturn(reader, new T[0]));
}
var items = new List <T>();
var parentDepth = arrayContent.MergeContent ? reader.Depth - 1 : reader.Depth;
var itemDepth = parentDepth + 1;
var itemName = arrayContent.Item.Content.Name;
if (!arrayContent.MergeContent)
{
reader.Read();
}
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
if (reader.GetXName() != itemName)
{
if (arrayContent.MergeContent)
{
break;
}
if (!arrayContent.Item.AcceptsAnyName)
{
var readerName = reader.GetXName();
throw new UnexpectedElementException($"Invalid array item name `{readerName}`.", Definition, arrayContent.Item, readerName);
}
}
if (reader.IsNilElement())
{
items.Add(default(T));
reader.Read();
continue;
}
var typeMap = serializer.GetTypeMapFromXsiType(reader, arrayContent.Item) ?? elementTypeMap;
var value = typeMap.Deserialize(reader, templateNode, arrayContent.Item.Content, message);
items.Add((T)value);
}
return(items.ToArray());
}
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);
}
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(XmlConvert.ToString((DateTime)value, "yyyy-MM-dd"));
}
/// <summary>
/// String serialization logic.
/// </summary>
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.WriteStringWithMode(value.ToString(), message.Protocol.Style.StringSerializationMode);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
return MoveNextAndReturn(reader, 0);
var value = reader.ReadElementContentAsString();
return string.IsNullOrEmpty(value) ? 0 : XmlConvert.ToInt16(value);
}
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());
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, 0M));
}
var value = reader.ReadElementContentAsString();
return(string.IsNullOrEmpty(value) ? 0M : XmlConvert.ToDecimal(value));
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
var typeMap = serializer.GetTypeMap(value.GetType());
if (typeMap == null)
{
throw new NotImplementedException($"No type definition provided for runtime type: {value.GetType().FullName}");
}
typeMap.Serialize(writer, templateNode, value, content, message);
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
message.Style.WriteType(writer, Definition, content);
if (!serializationMapping.TryGetValue((int)value, out var enumerationValue))
{
throw new UnexpectedValueException($"Cannot map value `{value}` to enumeration type `{Definition.Name}`.", Definition, value);
}
writer.WriteValue(enumerationValue);
}
/// <summary>
/// String deserialization logic.
/// </summary>
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, null));
}
var value = reader.ReadElementContentAsString();
return(string.IsNullOrEmpty(value) ? null : value);
}
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 new InvalidQueryException("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 new InvalidQueryException($"MIME multipart message does not contain message part with ID `{contentID}`.");
}
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, attachment.ContentStream));
}
reader.ReadToEndElement();
return(attachment.ContentStream);
}
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);
}
if (!serializationMapping.TryGetValue((int)value, out var enumerationValue))
{
throw new MissingFieldException($"Cannot map value `{value}` to enumeration type `{Definition.Name}`.");
}
writer.WriteValue(enumerationValue);
}
public void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
var attachment = new XRoadAttachment((Stream)value);
message.AllAttachments.Add(attachment);
message.Style.WriteType(writer, Definition, content);
writer.WriteStartElement(PrefixConstants.XOP, "Include", NamespaceConstants.XOP);
writer.WriteAttributeString("href", $"cid:{attachment.ContentID}");
writer.WriteEndElement();
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var isEmptyElement = reader.IsEmptyElement;
var stringValue = isEmptyElement ? "" : reader.ReadElementContentAsString();
if (!deserializationMapping.TryGetValue(stringValue, out var enumerationValue))
{
throw new MissingFieldException($"Unexpected value `{stringValue}` for enumeration type `{Definition.Name}`.");
}
var result = Enum.ToObject(Definition.Type, enumerationValue);
return(isEmptyElement ? MoveNextAndReturn(reader, result) : result);
}
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.ToBoolean(value));
}
public void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, ContentDefinition content, XRoadMessage message)
{
var attachment = new XRoadAttachment((Stream)value);
message.AllAttachments.Add(attachment);
if (!(content.Particle is RequestDefinition))
{
message.Style.WriteExplicitType(writer, Definition.Name);
}
writer.WriteStartElement(PrefixConstants.XOP, "Include", NamespaceConstants.XOP);
//writer.WriteAttributeString(PrefixConstants.XMIME, "contentType", NamespaceConstants.XMIME, "application/octet-stream");
writer.WriteAttributeString("href", $"cid:{attachment.ContentID}");
writer.WriteEndElement();
}
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 object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, new DateTime()));
}
var value = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(value))
{
return(null);
}
var dateTime = XmlConvert.ToDateTimeOffset(value).DateTime;
return(dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.TicksPerSecond)));
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
var entity = new T();
entity.SetTemplateMembers(templateNode.ChildNames);
var validateRequired = definition is RequestValueDefinition;
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, definition);
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, definition);
return(entity);
}
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);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, new DateTime()));
}
var value = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(value))
{
return(null);
}
var date = DateTime.ParseExact(value, dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None);
if (value[value.Length - 1] == 'Z')
{
date = date.ToLocalTime();
}
return(date);
}
