/// <summary> /// Annotates the payload element with atom:updated value. /// </summary> /// <param name="payloadElement">The payload element to annotate.</param> /// <param name="updatedValue">The value of the atom:update element.</param> /// <returns>The payload element with the annotation applied.</returns> public static T AtomUpdated <T>(this T payloadElement, string updatedValue) where T : ODataPayloadElement { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); payloadElement.Annotations.Add(XmlTreeAnnotation.Atom(TestAtomConstants.AtomUpdatedElementName, updatedValue)); return(payloadElement); }
/// <summary> /// Annotates the resource collection with out-of-line app:categories values. /// </summary> /// <param name="resourceCollection">The resource collection to annotate.</param> /// <param name="uri">The value of the app:categories href property.</param> /// <returns>The resource collection with the annotation applied.</returns> public static ResourceCollectionInstance AppOutOfLineCategories(this ResourceCollectionInstance resourceCollection, string uri) { ExceptionUtilities.CheckArgumentNotNull(resourceCollection, "resourceCollection"); resourceCollection.AddAnnotation(CreateAppElement("categories", null, XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomHRefAttributeName, uri))); return(resourceCollection); }
/// <summary> /// Annotates the entry with atom:published values. /// </summary> /// <param name="entry">The entry to annotate.</param> /// <param name="publishedDate">The value of the atom:published element.</param> /// <returns>The feed with the annotation applied.</returns> public static EntityInstance AtomPublished(this EntityInstance entry, string publishedDate) { ExceptionUtilities.CheckArgumentNotNull(entry, "entry"); entry.AddAnnotation(XmlTreeAnnotation.Atom(TestAtomConstants.AtomPublishedElementName, publishedDate)); return(entry); }
/// <summary> /// Annotates the feed with atom:logo values. /// </summary> /// <param name="feed">The feed to annotate.</param> /// <param name="uri">The value of the atom:logo element.</param> /// <returns>The feed with the annotation applied.</returns> public static EntitySetInstance AtomLogo(this EntitySetInstance feed, string uri) { ExceptionUtilities.CheckArgumentNotNull(feed, "feed"); feed.AddAnnotation(XmlTreeAnnotation.Atom(TestAtomConstants.AtomLogoElementName, uri)); return(feed); }
private static AtomGeneratorMetadata CreateGeneratorMetadata(XmlTreeAnnotation epmTree) { AtomGeneratorMetadata metadata = new AtomGeneratorMetadata() { Name = epmTree.PropertyValue }; foreach (XmlTreeAnnotation attribute in epmTree.Children.Where(child => child.IsAttribute)) { if (string.IsNullOrEmpty(attribute.NamespaceName)) { string localName = attribute.LocalName; if (localName == TestAtomConstants.AtomGeneratorUriAttributeName) { metadata.Uri = string.IsNullOrEmpty(attribute.PropertyValue) ? null : new Uri(attribute.PropertyValue); } else if (localName == TestAtomConstants.AtomGeneratorVersionAttributeName) { metadata.Version = attribute.PropertyValue; } else { throw new NotSupportedException("Unsupported metadata '" + localName + "' found for a generator."); } } } return(metadata); }
/// <summary> /// Normalizes a workspace or resource collection's Atom title property value so that it matches the element's title annotation. /// </summary> /// <param name="payloadElement">The payload element to normalize</param> /// <param name="titlePropertyValue">The value of the payload element's title property</param> /// <param name="setPropertyValue">Delegate for setting the payload element's title property</param> private void NormalizeTitleValue(ODataPayloadElement payloadElement, string titlePropertyValue, Action <string> setPropertyValue) { XmlTreeAnnotation titleXmlTreeAnnotation = payloadElement.Annotations .OfType <XmlTreeAnnotation>() .SingleOrDefault(a => a.LocalName.Equals(TestAtomConstants.AtomTitleElementName)); if (titlePropertyValue != null) { if (titleXmlTreeAnnotation != null) { string titleAnnotationValue = titleXmlTreeAnnotation.PropertyValue; if (titleAnnotationValue == null) { titleXmlTreeAnnotation.PropertyValue = titlePropertyValue; } else { ExceptionUtilities.Assert(titlePropertyValue == titleAnnotationValue, "Title in workspace or resource collection has different values : Property=" + titlePropertyValue + ", Annotation=" + titleAnnotationValue); } } else { payloadElement.AtomTitle(titlePropertyValue, TestAtomConstants.AtomTextConstructTextKind); } } else if (titleXmlTreeAnnotation != null) { setPropertyValue(titleXmlTreeAnnotation.PropertyValue); } }
private static void SerializeXmlTree(XmlTreeAnnotation xmlTree, XElement parent) { ExceptionUtilities.CheckArgumentNotNull(xmlTree, "xmlTree"); XNamespace targetNamespace = XNamespace.Get(xmlTree.NamespaceName); if (xmlTree.IsAttribute) { CreateAttribute(parent, xmlTree.LocalName, xmlTree.NamespaceName, xmlTree.PropertyValue); } else { XElement element = parent.Element(targetNamespace.GetName(xmlTree.LocalName)); // create new element for repeatable elements if (element == null || IsRepeatableElement(element)) { element = CreateElement(parent, xmlTree.NamespacePrefix, xmlTree.LocalName, xmlTree.NamespaceName); } foreach (var child in xmlTree.Children) { SerializeXmlTree(child, element); } if (xmlTree.PropertyValue != null) { element.Value = xmlTree.PropertyValue; } } }
public static T WithDefaultAtomIDAnnotation <T>(this T payloadElement) where T : ODataPayloadElement { XmlTreeAnnotation id = XmlTreeAnnotation.Atom(TestAtomConstants.AtomIdElementName, "urn:" + TestAtomConstants.AtomGuid); payloadElement.Annotations.Add(id); return(payloadElement); }
/// <summary> /// Annotates an ODataPayloadElement with an Atom Text construct. /// </summary> /// <typeparam name="T">The type of ODataPayloadElement.</typeparam> /// <param name="payloadElement">The payload element to annotate.</param> /// <param name="elementName">The name of the Text element.</param> /// <param name="textValue">The value of the Text element.</param> /// <returns>The payload element with annotation applied.</returns> private static T AtomText <T>(this T payloadElement, string elementName, string textValue, string textType) where T : ODataPayloadElement { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var textAttributes = CreateAtomAttributes(new KeyValuePair <string, string>(TestAtomConstants.AtomTypeAttributeName, textType)); payloadElement.AddAnnotation(XmlTreeAnnotation.Atom(elementName, textValue, textAttributes)); return(payloadElement); }
private static T WithDefaultAtomTitleAnnotation <T>(this T payloadElement) where T : ODataPayloadElement { XmlTreeAnnotation title = XmlTreeAnnotation.Atom("title", null); title.Children.Add(XmlTreeAnnotation.AtomAttribute("type", "text")); payloadElement.Annotations.Add(title); return(payloadElement); }
private static T WithDefaultAtomUpdatedAnnotation <T>(this T payloadElement) where T : ODataPayloadElement { XmlTreeAnnotation updated = XmlTreeAnnotation.Atom(TestAtomConstants.AtomUpdatedElementName, "2013-08-13T01:03:16.7800000-7"); payloadElement.Annotations.Add(updated); return(payloadElement); }
/// <summary> /// Converts the ATOM metadata annotation of stream properties and assocation links /// into XmlTree annotations and removes the stream properties/association links from the payload. /// </summary> /// <param name="payloadElement">The entity instance to visit.</param> public override void Visit(EntityInstance payloadElement) { IEnumerable <PropertyInstance> properties = payloadElement.Properties; if (properties != null) { // First remove all the stream properties in request payloads if (this.readerTestConfiguration.IsRequest) { List <NamedStreamInstance> streamProperties = properties.OfType <NamedStreamInstance>().ToList(); foreach (var streamProperty in streamProperties) { // Edit link string editRelationValue = TestAtomConstants.ODataStreamPropertyEditMediaRelatedLinkRelationPrefix + streamProperty.Name; XmlTreeAnnotation annotation = GetStreamPropertyLinkXmlTreeAnnotation(streamProperty, editRelationValue); if (annotation != null) { payloadElement.AddAnnotation(annotation); } // Self link string sourceRelationValue = TestAtomConstants.ODataStreamPropertyMediaResourceRelatedLinkRelationPrefix + streamProperty.Name; annotation = GetStreamPropertyLinkXmlTreeAnnotation(streamProperty, sourceRelationValue); if (annotation != null) { payloadElement.AddAnnotation(annotation); } payloadElement.Remove(streamProperty); } } // Then also convert the association links of navigation properties and // remove all navigation properties that do not have a URI - for request if (this.readerTestConfiguration.IsRequest) { List <NavigationPropertyInstance> navigationProperties = properties.OfType <NavigationPropertyInstance>().ToList(); foreach (var navProperty in navigationProperties) { XmlTreeAnnotation annotation = GetAssociationLinkXmlTreeAnnotation(navProperty.AssociationLink); navProperty.AssociationLink = null; if (navProperty.Value == null) { payloadElement.Remove(navProperty); } if (annotation != null) { payloadElement.AddAnnotation(annotation); } } } } base.Visit(payloadElement); }
/// <summary> /// Creates an annotation representing an atom:category element. /// </summary> /// <param name="term">The value of the atom:category's term property.</param> /// <param name="scheme">The value of the atom:category's scheme property.</param> /// <param name="label">The value of the atom:category's label property.</param> /// <returns>An annotation representing the atom:category.</returns> public static XmlTreeAnnotation AtomCategory(string term, string scheme, string label) { var categoryAttributes = CreateAtomAttributes( new KeyValuePair <string, string>(TestAtomConstants.AtomCategoryTermAttributeName, term), new KeyValuePair <string, string>(TestAtomConstants.AtomCategorySchemeAttributeName, scheme), new KeyValuePair <string, string>(TestAtomConstants.AtomCategoryLabelAttributeName, label)); return(XmlTreeAnnotation.Atom(TestAtomConstants.AtomCategoryElementName, null, categoryAttributes)); }
/// <summary> /// Creates the XmlTreeAnnotation annotations that represent the attributes with non-null values. /// </summary> /// <param name="attributeNameValuePairs">The attribute name-value pairs to convert to Atom attribute annotations.</param> /// <returns>An XmlTreeAnnotation for each non-null value attribute.</returns> private static XmlTreeAnnotation[] CreateAtomAttributes(params KeyValuePair <string, string>[] attributeNameValuePairs) { var atomAttributes = new List <XmlTreeAnnotation>(); foreach (var attribute in attributeNameValuePairs.Where(p => p.Value != null)) { atomAttributes.Add(XmlTreeAnnotation.AtomAttribute(attribute.Key, attribute.Value)); } return(atomAttributes.ToArray()); }
/// <summary> /// Creates the XmlTreeAnnotation annotations that represent the elements with non-null values. /// </summary> /// <param name="attributeNameValuePairs">The element name-value pairs to convert to Atom element annotations.</param> /// <returns>An XmlTreeAnnotation for each non-null value element.</returns> private static XmlTreeAnnotation[] CreateAtomElements(params KeyValuePair <string, string>[] elementNameValuePairs) { var atomElements = new List <XmlTreeAnnotation>(); foreach (var element in elementNameValuePairs.Where(p => p.Value != null)) { atomElements.Add(XmlTreeAnnotation.Atom(element.Key, element.Value)); } return(atomElements.ToArray()); }
/// <summary> /// Annotates the feed with atom:generator values. /// </summary> /// <param name="feed">The feed to annotate.</param> /// <param name="name">The value of the atom:generator element.</param> /// <param name="uri">The value of the atom:generator's URI property.</param> /// <param name="version">The value of the atom:generator's version property.</param> /// <returns>The feed with the annotation applied.</returns> public static EntitySetInstance AtomGenerator(this EntitySetInstance feed, string name, string uri, string version) { ExceptionUtilities.CheckArgumentNotNull(feed, "feed"); var generatorAttributes = CreateAtomAttributes( new KeyValuePair <string, string>(TestAtomConstants.AtomGeneratorUriAttributeName, uri), new KeyValuePair <string, string>(TestAtomConstants.AtomGeneratorVersionAttributeName, version)); feed.AddAnnotation(XmlTreeAnnotation.Atom(TestAtomConstants.AtomGeneratorElementName, name, generatorAttributes)); return(feed); }
/// <summary> /// Computes the XmlTreeAnnotation for an association link. /// </summary> /// <param name="associationLink">The association link to compute the stream property for.</param> /// <returns>The <see cref="XmlTreeAnnotation"/> for the link specified in <paramref name="associationLink"/>.</returns> private XmlTreeAnnotation GetAssociationLinkXmlTreeAnnotation(DeferredLink associationLink) { if (associationLink == null) { return(null); } // Add all the attributes that are already stored on the association link as annotations List <XmlTreeAnnotation> attributes = new List <XmlTreeAnnotation>(); attributes.AddRange(associationLink.Annotations.OfType <XmlTreeAnnotation>().Where(a => a.IsAttribute)); return(XmlTreeAnnotation.Atom(TestAtomConstants.AtomLinkElementName, null, attributes.ToArray())); }
/// <summary> /// Annotates an ODataPayloadElement with an Atom Person construct. /// </summary> /// <typeparam name="T">The type of ODataPayloadElement.</typeparam> /// <param name="payloadElement">The payload element to annotate.</param> /// <param name="elementName">The name of the Person element.</param> /// <param name="personName">The value of the Person's Name property.</param> /// <param name="personUri">The value of the Person's Uri property.</param> /// <param name="personEmail">The value of the Person's Email Address property.</param> /// <returns>The payload element with annotation applied.</returns> private static T AtomPerson <T>(this T payloadElement, string elementName, string personName, string personUri, string personEmail) where T : ODataPayloadElement { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var personChildren = CreateAtomElements( new KeyValuePair <string, string>(TestAtomConstants.AtomPersonNameElementName, personName), new KeyValuePair <string, string>(TestAtomConstants.AtomPersonUriElementName, personUri), new KeyValuePair <string, string>(TestAtomConstants.AtomPersonEmailElementName, personEmail)); XmlTreeAnnotation person = XmlTreeAnnotation.Atom(elementName, null, personChildren); payloadElement.AddAnnotation(person); return(payloadElement); }
/// <summary> /// Annotates the payload element with a link annotation and adds the given atom:link attribute values as children on that annotation. /// </summary> /// <param name="payloadElement">The payload element to annotate.</param> /// <param name="href">The value of the atom:link's href property</param> /// <param name="rel">The value of the atom:link's rel property</param> /// <param name="type">The value of the atom:link's type property</param> /// <param name="hrefLang">The optional value of the atom:link's hrefLang property</param> /// <param name="title">The optional value of the atom:link's title property</param> /// <param name="length">The optional value of the atom:link's length property</param> /// <returns>The payload element with the annotation applied.</returns> public static T AtomLink <T>(this T payloadElement, string href, string rel, string type, string hrefLang = null, string title = null, string length = null) where T : ODataPayloadElement { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var linkAttributes = CreateAtomAttributes( new KeyValuePair <string, string>(TestAtomConstants.AtomLinkHrefAttributeName, href), new KeyValuePair <string, string>(TestAtomConstants.AtomLinkRelationAttributeName, rel), new KeyValuePair <string, string>(TestAtomConstants.AtomLinkTypeAttributeName, type), new KeyValuePair <string, string>(TestAtomConstants.AtomLinkHrefLangAttributeName, hrefLang), new KeyValuePair <string, string>(TestAtomConstants.AtomLinkTitleAttributeName, title), new KeyValuePair <string, string>(TestAtomConstants.AtomLinkLengthAttributeName, length)); payloadElement.AddAnnotation(XmlTreeAnnotation.Atom(TestAtomConstants.AtomLinkElementName, null, linkAttributes)); return(payloadElement); }
/// <summary> /// Annotates the entry with atom:source values. /// </summary> /// <param name="entry">The entry to annotate.</param> /// <param name="sourceFeed">The feed containing metadata to copy.</param> /// <returns>The entry with the annotation applied.</returns> public static EntityInstance AtomSource(this EntityInstance entry, EntitySetInstance sourceFeed) { ExceptionUtilities.CheckArgumentNotNull(entry, "entry"); ExceptionUtilities.CheckArgumentNotNull(sourceFeed, "sourceFeed"); var sourceAnnotations = sourceFeed.Annotations.OfType <XmlTreeAnnotation>(); entry.AddAnnotation( XmlTreeAnnotation.Atom( TestAtomConstants.AtomSourceElementName, null, sourceAnnotations.Select(a => (XmlTreeAnnotation)a.Clone()).ToArray())); return(entry); }
/// <summary> /// Normalizes navigation property specific atom metadata. /// </summary> /// <param name="payloadElement">The payload element to normalize.</param> public override void Visit(NavigationPropertyInstance payloadElement) { DeferredLink deferredLink = payloadElement.Value as DeferredLink; if (deferredLink != null) { // If there is a type annotation specified as a XmlTreeAnnotion, copy its value over to a ContentTypeAnnotation as well. XmlTreeAnnotation typeAnnotation = deferredLink.Annotations.OfType <XmlTreeAnnotation>().SingleOrDefault(a => a.LocalName == TestAtomConstants.AtomLinkTypeAttributeName); if (typeAnnotation != null) { deferredLink.WithContentType(typeAnnotation.PropertyValue); } } base.Visit(payloadElement); }
/// <summary> /// Computes the XmlTreeAnnotation for a stream property from the <see cref="NamedStreamAtomLinkMetadataAnnotation"/>. /// </summary> /// <param name="streampProperty">The stream property to compute the Xml annotation for.</param> /// <param name="relation">The relation of the link we are converting</param> /// <returns>The <see cref="XmlTreeAnnotation"/> for the link with the specified <paramref name="relation"/>.</returns> private XmlTreeAnnotation GetStreamPropertyLinkXmlTreeAnnotation(NamedStreamInstance streampProperty, string relation) { // Look it up again since it was created above. NamedStreamAtomLinkMetadataAnnotation linkAnnotation = streampProperty.Annotations.OfType <NamedStreamAtomLinkMetadataAnnotation>().SingleOrDefault(a => a.Relation == relation); if (linkAnnotation == null) { return(null); } List <XmlTreeAnnotation> attributes = new List <XmlTreeAnnotation>(); if (linkAnnotation.Href != null) { attributes.Add(XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkHrefAttributeName, linkAnnotation.Href)); } if (linkAnnotation.HrefLang != null) { attributes.Add(XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkHrefLangAttributeName, linkAnnotation.HrefLang)); } if (linkAnnotation.Length != null) { attributes.Add(XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkLengthAttributeName, linkAnnotation.Length)); } if (linkAnnotation.Relation != null) { attributes.Add(XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkRelationAttributeName, linkAnnotation.Relation)); } if (linkAnnotation.Title != null) { attributes.Add(XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkTitleAttributeName, linkAnnotation.Title)); } if (linkAnnotation.Type != null) { attributes.Add(XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkTypeAttributeName, linkAnnotation.Type)); } return(XmlTreeAnnotation.Atom(TestAtomConstants.AtomLinkElementName, null, attributes.ToArray())); }
/// <summary> /// Converts the Object Model representation of Atom link metadata into appropriate annotations for a payload element representing a link. /// </summary> /// <param name="linkMetadata">The Atom link metadata, in Object Model representation, to convert.</param> /// <param name="linkPayloadElement">The link payload element to annotate.</param> /// <remarks>This method is only for use with payload elements that represent links, as it will skip over the root link annotation.</remarks> private static void ConvertAtomLinkChildrenMetadata(AtomLinkMetadata linkMetadata, ODataPayloadElement linkPayloadElement) { ExceptionUtilities.CheckArgumentNotNull(linkMetadata, "linkMetadata"); ExceptionUtilities.CheckArgumentNotNull(linkPayloadElement, "linkPayloadElement"); // Since the payload element already represents a link, we annotate a temporary element // and copy the "children" annotations onto the actual payload element. var tempPayloadElement = new EntityInstance(); ExceptionUtilities.Assert(!tempPayloadElement.Annotations.OfType <XmlTreeAnnotation>().Any(), "Payload element should not have XmlTreeAnnotations after construction"); ConvertAtomLinkMetadata(linkMetadata, tempPayloadElement); XmlTreeAnnotation linkAnnotation = tempPayloadElement.Annotations.OfType <XmlTreeAnnotation>().Single(); foreach (XmlTreeAnnotation childAnnotation in linkAnnotation.Children) { linkPayloadElement.AddAnnotation(childAnnotation); } }
/// <summary> /// Normalizes an Atom link property value between an XmlTreeAnnotation and another property. /// </summary> /// <typeparam name="T">The type of payload element.</typeparam> /// <param name="payloadElement">The payload element to normalize.</param> /// <param name="relationValue">The relation value of the link to normalize.</param> /// <param name="attributeName">The name of the link attribute to normalize.</param> /// <param name="getOtherLinkValue">Function for retrieving the other value for the link property.</param> /// <param name="setOtherLinkValue">Delegate for setting the other value for the link property.</param> private void NormalizeLinkValue <T>(T payloadElement, string relationValue, string attributeName, Func <T, string> getOtherLinkValue, Action <T, string> setOtherLinkValue) where T : ODataPayloadElement { string otherLinkValue = getOtherLinkValue(payloadElement); XmlTreeAnnotation linkXmlTreeAnnotation = payloadElement.Annotations .OfType <XmlTreeAnnotation>() .SingleOrDefault(a => a.LocalName.Equals(TestAtomConstants.AtomLinkElementName) && HasAttribute(a, TestAtomConstants.AtomLinkRelationAttributeName, relationValue)); if (otherLinkValue != null) { if (linkXmlTreeAnnotation != null) { var linkAttribute = GetAttributeAnnotation(linkXmlTreeAnnotation, attributeName); if (linkAttribute == null) { linkXmlTreeAnnotation.Children.Add(XmlTreeAnnotation.AtomAttribute(attributeName, otherLinkValue)); } else if (linkAttribute.PropertyValue != otherLinkValue) { ExceptionUtilities.Assert(otherLinkValue.Equals(linkAttribute.PropertyValue), attributeName + " value for link '" + relationValue + "' does not match value on Xml Tree"); } } else { // Add an xml tree annotation to match the value from the other source. payloadElement.Add( XmlTreeAnnotation.Atom( TestAtomConstants.AtomLinkElementName, null, XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkRelationAttributeName, relationValue), XmlTreeAnnotation.AtomAttribute(attributeName, otherLinkValue))); } } else if (linkXmlTreeAnnotation != null) { // Set the other source to match the atom:link href value of the annotation var linkAttribute = GetAttributeAnnotation(linkXmlTreeAnnotation, attributeName); if (linkAttribute != null) { setOtherLinkValue(payloadElement, linkAttribute.PropertyValue); } } }
/// <summary> /// Annotates a payload element representing a link with atom:link attribute values. /// </summary> /// <param name="linkPayloadElement">The payload element to annotate.</param> /// <param name="href">The value of the atom:link's href property</param> /// <param name="rel">The value of the atom:link's rel property</param> /// <param name="type">The value of the atom:link's type property</param> /// <param name="hrefLang">The optional value of the atom:link's hrefLang property</param> /// <param name="title">The optional value of the atom:link's title property</param> /// <param name="length">The optional value of the atom:link's length property</param> /// <returns>The payload element with the annotation applied.</returns> public static T AtomLinkAttributes <T>(this T linkPayloadElement, string href, string rel, string type, string hrefLang = null, string title = null, string length = null) where T : ODataPayloadElement { ExceptionUtilities.CheckArgumentNotNull(linkPayloadElement, "linkPayloadElement"); // Since the payload element already represents a link, we annotate a temporary element // and copy the "children" annotations onto the actual payload element. var tempPayloadElement = new EntityInstance(); ExceptionUtilities.Assert(!tempPayloadElement.Annotations.OfType <XmlTreeAnnotation>().Any(), "Payload element should not have XmlTreeAnnotations after construction"); tempPayloadElement.AtomLink(href, rel, type, hrefLang, title, length); XmlTreeAnnotation linkAnnotation = tempPayloadElement.Annotations.OfType <XmlTreeAnnotation>().Single(); foreach (XmlTreeAnnotation childAnnotation in linkAnnotation.Children) { linkPayloadElement.AddAnnotation(childAnnotation); } return(linkPayloadElement); }
private bool CompareAnnotation(ODataPayloadElementAnnotation expectedAnnotation, ODataPayloadElementAnnotation observedAnnotation, out string errorMessage) { try { errorMessage = null; this.Assert.AreEqual(expectedAnnotation.GetType(), observedAnnotation.GetType(), "Annotation types should be same"); if (expectedAnnotation is XmlTreeAnnotation) { XmlTreeAnnotation e = expectedAnnotation as XmlTreeAnnotation; XmlTreeAnnotation o = observedAnnotation as XmlTreeAnnotation; this.Assert.IsNotNull(o, "Observed annotation cannot be null"); this.Assert.AreEqual(e.LocalName, o.LocalName, "Local names should match"); this.Assert.AreEqual(e.NamespaceName, o.NamespaceName, "Namespace names should be equal"); this.Assert.AreEqual(e.PropertyValue, o.PropertyValue, "Property values must be equal"); this.Assert.AreEqual(e.IsAttribute, o.IsAttribute, "IsAttribute values should be equal"); this.Assert.AreEqual(e.Children.Count, o.Children.Count, "Children count must be equal"); Compare(e.Children.Cast <ODataPayloadElementAnnotation>().ToList(), o.Children.Cast <ODataPayloadElementAnnotation>().ToList()); } else if (expectedAnnotation is SelfLinkAnnotation) { SelfLinkAnnotation e = expectedAnnotation as SelfLinkAnnotation; SelfLinkAnnotation o = observedAnnotation as SelfLinkAnnotation; this.Assert.IsNotNull(o, "Observed annotation cannot be null"); this.Assert.AreEqual(e.Value, o.Value, "Values should match"); } else if (expectedAnnotation is ContentTypeAnnotation) { ContentTypeAnnotation e = expectedAnnotation as ContentTypeAnnotation; ContentTypeAnnotation o = observedAnnotation as ContentTypeAnnotation; this.Assert.IsNotNull(o, "Observed annotation cannot be null"); this.Assert.AreEqual(e.Value, o.Value, "Values should match"); } return(true); } catch (DataComparisonException e) { errorMessage = "Message: " + e.Message + " Exception type:" + e.GetType() + " Stack:" + e.StackTrace; return(false); } }
/// <summary> /// Builds the entity-property-mapping tree represented by the given xml element /// </summary> /// <param name="element">The element to build from</param> /// <returns>The entity-property-mapping tree</returns> private XmlTreeAnnotation BuildEpmTree(XElement element) { var mappedProperty = new XmlTreeAnnotation() { IsAttribute = false, LocalName = element.Name.LocalName, NamespaceName = element.Name.NamespaceName, NamespacePrefix = element.GetPrefixOfNamespace(element.Name.Namespace), PropertyValue = element.Nodes().OfType <XText>().Select(t => t.Value).SingleOrDefault(), }; foreach (var subElement in element.Elements()) { mappedProperty.Children.Add(this.BuildEpmTree(subElement)); } foreach (var attribute in element.Attributes().Where(a => !a.IsNamespaceDeclaration)) { mappedProperty.Children.Add(this.BuildEpmTree(attribute)); } return(mappedProperty); }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(EntitySetInstance payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); XmlTreeAnnotation updated = XmlTreeAnnotation.Atom(TestAtomConstants.AtomUpdatedElementName, "2013-08-13T01:03:16.7800000"); updated.SetValueEqualityFunc((obj1, obj2) => { return(true); }); payloadElement.Annotations.Add(updated); payloadElement.Add(XmlTreeAnnotation.Atom("title", null)); //If a feed is empty it must have an author bool feedEmpty = payloadElement.Count == 0; if (feedEmpty) { XmlTreeAnnotation author = XmlTreeAnnotation.Atom(TestAtomConstants.AtomAuthorElementName, null, XmlTreeAnnotation.Atom(TestAtomConstants.AtomAuthorNameElementName, null)); payloadElement.Annotations.Add(author); } base.Visit(payloadElement); }
/// <summary> /// Searches the tree annotation for an attribute of specific name and value. /// </summary> /// <param name="annotation">The tree annotation to search.</param> /// <param name="attributeName">The name of attribute to find.</param> /// <param name="attributeValue">The value of attribute to find.</param> /// <returns>true if the specified attribute name/value was found, false otherwise.</returns> private static bool HasAttribute(XmlTreeAnnotation annotation, string attributeName, string attributeValue) { return(annotation.Children.Any(a => a.IsAttribute && a.LocalName == attributeName && a.PropertyValue == attributeValue)); }
/// <summary> /// Retrieves the attribute annotation that is an immediate child of the tree annotation. /// </summary> /// <param name="annotation">The tree annotation to search.</param> /// <param name="attributeName">The name of the attribute to retrieve.</param> /// <returns>The specified attribute annotation, or null if no matching attributes found.</returns> private static XmlTreeAnnotation GetAttributeAnnotation(XmlTreeAnnotation annotation, string attributeName) { return(annotation.Children.SingleOrDefault(a => a.IsAttribute && a.LocalName.Equals(attributeName))); }