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