Exemple #1
0
        /// <summary>
        /// Initializes the EPM annotation with EPM information from the specified resource type.
        /// </summary>
        /// <param name="definingResourceType">Resource type to use the EPM infromation from.</param>
        /// <param name="affectedResourceType">Resource type for this the EPM information is being built.</param>
        private void BuildEpmForType(ResourceType definingResourceType, ResourceType affectedResourceType)
        {
            Debug.Assert(definingResourceType != null, "definingResourceType != null");
            Debug.Assert(affectedResourceType != null, "affectedResourceType != null");

            if (definingResourceType.BaseType != null)
            {
                this.BuildEpmForType(definingResourceType.BaseType, affectedResourceType);
            }

            EpmResourceTypeAnnotation epm = definingResourceType.Epm();

            if (epm != null)
            {
                foreach (EntityPropertyMappingAttribute epmAttribute in epm.AllEpmAttributes.ToList())
                {
                    this.epmSourceTree.Add(new EntityPropertyMappingInfo(epmAttribute, definingResourceType, affectedResourceType));

                    if (definingResourceType == affectedResourceType)
                    {
                        if (!PropertyExistsOnType(affectedResourceType, epmAttribute))
                        {
                            this.InheritedEpmAttributes.Add(epmAttribute);
                            this.OwnEpmAttributes.Remove(epmAttribute);
                        }
                        else
                        {
                            Debug.Assert(
                                this.OwnEpmAttributes.SingleOrDefault(attr => Object.ReferenceEquals(epmAttribute, attr)) != null,
                                "Own epmInfo should already have the given instance");
                        }
                    }
                }
            }
        }
Exemple #2
0
        /// <summary>
        /// Initializes the EPM internal information for the specified resource type and all its base types.
        /// </summary>
        /// <param name="resourceType">The resource type to build the EPM information for.</param>
        /// <remarks>If the type in question has no EPM attributes anywhere in its hierarchy this method will do nothing.</remarks>
        internal static void BuildEpm(ResourceType resourceType)
        {
            DebugUtils.CheckNoExternalCallers();
            Debug.Assert(resourceType != null, "resourceType != null");

            // Walk the base types and determine if there's EPM anywhere in there.
            bool         hasEpm             = false;
            ResourceType resourceTypeToTest = resourceType;

            while (resourceTypeToTest != null)
            {
                if (resourceTypeToTest.Epm() != null)
                {
                    hasEpm = true;
                    break;
                }

                resourceTypeToTest = resourceTypeToTest.BaseType;
            }

            // If there is build the EPM information for this type and add it as annotation.
            if (hasEpm)
            {
                EpmResourceTypeAnnotation epm = resourceType.Epm();
                if (epm == null)
                {
                    epm = new EpmResourceTypeAnnotation();
                    // resourceType.SetAnnotation(epm);
                }

                epm.BuildEpmForType(resourceType, resourceType);
            }
        }
		/// <summary>
		/// Adds an <see cref="EntityPropertyMappingAttribute"/> for the resource type.
		/// </summary>
		/// <param name="attribute">Given <see cref="EntityPropertyMappingAttribute"/>.</param>
		public void AddEntityPropertyMappingAttribute(EntityPropertyMappingAttribute attribute)
		{
			ExceptionUtils.CheckArgumentNotNull(attribute, "attribute");

			// EntityPropertyMapping attribute can not be added to readonly resource types.
			this.ThrowIfSealed();

			if (this.ResourceTypeKind != ResourceTypeKind.EntityType)
			{
				throw new InvalidOperationException(Strings.ResourceType_EpmOnlyAllowedOnEntityTypes(this.Name));
			}

			// Initialize the EPM annotation for this type
			EpmResourceTypeAnnotation epm = this.Epm();
			if (epm == null)
			{
				epm = new EpmResourceTypeAnnotation();
				this.SetAnnotation(epm);
			}

			// And add the attribute to it
			epm.OwnEpmAttributes.Add(attribute);
		}
        /// <summary>
        /// Initializes the EPM internal information for the specified resource type and all its base types.
        /// </summary>
        /// <param name="resourceType">The resource type to build the EPM information for.</param>
        /// <remarks>If the type in question has no EPM attributes anywhere in its hierarchy this method will do nothing.</remarks>
        internal static void BuildEpm(ResourceType resourceType)
        {
            DebugUtils.CheckNoExternalCallers();
            Debug.Assert(resourceType != null, "resourceType != null");

            // Walk the base types and determine if there's EPM anywhere in there.
            bool hasEpm = false;
            ResourceType resourceTypeToTest = resourceType;
            while (resourceTypeToTest != null)
            {
                if (resourceTypeToTest.Epm() != null)
                {
                    hasEpm = true;
                    break;
                }

                resourceTypeToTest = resourceTypeToTest.BaseType;
            }

            // If there is build the EPM information for this type and add it as annotation.
            if (hasEpm)
            {
                EpmResourceTypeAnnotation epm = resourceType.Epm();
                if (epm == null)
                {
                    epm = new EpmResourceTypeAnnotation();
                    // resourceType.SetAnnotation(epm);
                }

                epm.BuildEpmForType(resourceType, resourceType);
            }
        }
Exemple #5
0
        /// <summary>
        /// Finish writing an entry.
        /// </summary>
        /// <param name="entry">The entry to write.</param>
        protected override void EndEntry(ODataEntry entry)
        {
            Debug.Assert(entry != null, "entry != null");

            string       typeName  = entry.TypeName;
            ResourceType entryType = ValidationUtils.ValidateTypeName(this.MetadataProvider, typeName, ResourceTypeKind.EntityType, false);

            // Initialize the property value cache and cache the entry properties.
            EntryPropertiesValueCache propertyValueCache        = new EntryPropertiesValueCache(entry);
            EpmResourceTypeAnnotation epmResourceTypeAnnotation = null;

            if (entryType != null)
            {
                Debug.Assert(entryType.IsReadOnly, "The resource must be read-only to be applied to an entry.");
                entryType.EnsureEpmAvailability();
                epmResourceTypeAnnotation = entryType.Epm();
            }

            // <atom:id>idValue</atom:id>
            // NOTE: do not generate a relative Uri for the ID; it is independent of xml:base
            ODataAtomWriterUtils.WriteElementWithTextContent(
                this.writer,
                AtomConstants.AtomNamespacePrefix,
                AtomConstants.AtomIdElementName,
                AtomConstants.AtomNamespace,
                entry.Id);

            // <category term="type" scheme="odatascheme"/>
            // If no type information is provided, don't include the category element for type at all
            // NOTE: the validation of the type name happened at the beginning of this method.
            if (typeName != null)
            {
                ODataAtomWriterMetadataUtils.WriteCategory(this.writer, typeName, AtomConstants.ODataSchemeNamespace, null);
            }

            Uri editLink = entry.EditLink;

            if (editLink != null)
            {
                // <link rel="edit" title="Title" href="LinkHRef"/>
                ODataAtomWriterUtils.WriteReadOrEditLink(this.writer, this.BaseUri, editLink, AtomConstants.AtomEditRelationAttributeValue, typeName);
            }

            Uri readLink = entry.ReadLink;

            if (readLink != null)
            {
                // <link rel="self" title="Title" href="LinkHRef"/>
                ODataAtomWriterUtils.WriteReadOrEditLink(this.writer, this.BaseUri, readLink, AtomConstants.AtomSelfRelationAttributeValue, typeName);
            }

            // named streams
            IEnumerable <ODataMediaResource> namedStreams = entry.NamedStreams;

            if (namedStreams != null)
            {
                foreach (ODataMediaResource namedStream in namedStreams)
                {
                    ValidationUtils.ValidateNamedStream(namedStream, this.Version);

                    ODataAtomWriterUtils.WriteNamedStream(this.writer, this.BaseUri, namedStream);
                }
            }

            // association links
            IEnumerable <ODataAssociationLink> associationLinks = entry.AssociationLinks;

            if (associationLinks != null)
            {
                foreach (ODataAssociationLink associationLink in associationLinks)
                {
                    ValidationUtils.ValidateAssociationLink(associationLink, this.Version);

                    ODataAtomWriterUtils.WriteAssociationLink(this.writer, this.BaseUri, entry, associationLink);
                }
            }

            // write entry metadata including syndication EPM
            AtomEntryMetadata epmEntryMetadata = null;

            if (epmResourceTypeAnnotation != null)
            {
                ODataVersionChecker.CheckEntityPropertyMapping(this.Version, entryType);

                epmEntryMetadata = EpmSyndicationWriter.WriteEntryEpm(
                    epmResourceTypeAnnotation.EpmTargetTree,
                    propertyValueCache,
                    entryType,
                    this.MetadataProvider,
                    this.Version);
            }

            ODataAtomWriterMetadataUtils.WriteEntryMetadata(this.writer, this.BaseUri, entry, epmEntryMetadata);

            // write the content
            this.WriteEntryContent(entry, entryType, propertyValueCache, epmResourceTypeAnnotation == null ? null : epmResourceTypeAnnotation.EpmSourceTree.Root);

            // write custom EPM
            if (epmResourceTypeAnnotation != null)
            {
                EpmCustomWriter.WriteEntryEpm(
                    this.writer,
                    epmResourceTypeAnnotation.EpmTargetTree,
                    propertyValueCache,
                    entryType,
                    this.MetadataProvider);
            }

            // </entry>
            this.writer.WriteEndElement();
        }