Support Instance annotations using annotation container

src/Microsoft.AspNetCore.OData/Deltas/DeltaOfT.cs

@@ -17,6 +17,7 @@
 using System.Runtime.Serialization;
 using Microsoft.AspNetCore.OData.Abstracts;
 using Microsoft.AspNetCore.OData.Common;
+using Microsoft.OData.ModelBuilder;
 
 namespace Microsoft.AspNetCore.OData.Deltas
 {
@@ -47,6 +48,9 @@ private static readonly ConcurrentDictionary<Type, Dictionary<string, PropertyAc
         private HashSet<string> _changedDynamicProperties;
         private IDictionary<string, object> _dynamicDictionaryCache;
 
+        private PropertyInfo _instanceAnnotationContainerPropertyInfo;
+        private IODataInstanceAnnotationContainer _instanceAnnotationContainer;
+
         /// <summary>
         /// Initializes a new instance of <see cref="Delta{T}"/>.
         /// </summary>
@@ -150,6 +154,20 @@ public override bool TrySetPropertyValue(string name, object value)
                 throw Error.ArgumentNull(nameof(name));
             }
 
+            if (IsInstanceAnnotation(name, out PropertyInfo annotationContainerPropertyInfo))
+            {
+                IODataInstanceAnnotationContainer annotationContainer = value as IODataInstanceAnnotationContainer;
+                if (value != null && annotationContainer == null)
+                {
+                    return false;
+                }
+
+                annotationContainerPropertyInfo.SetValue(_instance, annotationContainer);
+                _instanceAnnotationContainer = annotationContainer;
+                _instanceAnnotationContainerPropertyInfo = annotationContainerPropertyInfo;
+                return true;
+            }
+
             if (_dynamicDictionaryPropertyinfo != null)
             {
                 // Dynamic property can have the same name as the dynamic property dictionary.
@@ -374,6 +392,8 @@ public void CopyChangedValues(T original)
 
             CopyChangedDynamicValues(original);
 
+            CopyInstanceAnnotations(original);
+
             // For nested resources.
             foreach (string nestedResourceName in _deltaNestedResources.Keys)
             {
@@ -685,6 +705,44 @@ private static bool IsIgnoredProperty(bool isTypeDataContract, PropertyInfo prop
             return propertyInfo.GetCustomAttributes(typeof(IgnoreDataMemberAttribute), inherit: true).Any();
         }
 
+        private void CopyInstanceAnnotations(T targetEntity)
+        {
+            if (_instanceAnnotationContainerPropertyInfo == null)
+            {
+                return;
+            }
+
+            IODataInstanceAnnotationContainer sourceContainer =
+                _instanceAnnotationContainerPropertyInfo.GetValue(_instance) as IODataInstanceAnnotationContainer;
+            if (sourceContainer == null)
+            {
+                return;
+            }
+
+            IODataInstanceAnnotationContainer desContainer =
+                _instanceAnnotationContainerPropertyInfo.GetValue(targetEntity) as IODataInstanceAnnotationContainer;
+            if (desContainer == null)
+            {
+                _instanceAnnotationContainerPropertyInfo.SetValue(targetEntity, sourceContainer);
+                return;
+            }
+
+            foreach (var item in sourceContainer.InstanceAnnotations)
+            {
+                foreach (var annotation in item.Value)
+                {
+                    if (item.Key == null || item.Key == string.Empty)
+                    {
+                        desContainer.AddResourceAnnotation(annotation.Key, annotation.Value);
+                    }
+                    else
+                    {
+                        desContainer.AddPropertyAnnotation(item.Key, annotation.Key, annotation.Value);
+                    }
+                }
+            }
+        }
+
         // Copy changed dynamic properties and leave the unchanged dynamic properties
         private void CopyChangedDynamicValues(T targetEntity)
         {
@@ -842,5 +900,24 @@ private bool TrySetNestedResourceInternal(string name, object deltaNestedResourc
 
             return true;
         }
+
+        private bool IsInstanceAnnotation(string name, out PropertyInfo propertyInfo)
+        {
+            propertyInfo = null;
+            if (!_allProperties.TryGetValue(name, out PropertyAccessor<T> propertyAccessor))
+            {
+                return false;
+            }
+
+            propertyInfo = propertyAccessor.Property;
+
+            if (propertyInfo.PropertyType == typeof(ODataInstanceAnnotationContainer) ||
+                typeof(IODataInstanceAnnotationContainer).IsAssignableFrom(propertyInfo.PropertyType))
+            {
+                return true;
+            }
+
+            return false;
+        }
     }
 }

src/Microsoft.AspNetCore.OData/Edm/EdmModelAnnotationExtensions.cs

@@ -217,6 +217,34 @@ public static PropertyInfo GetDynamicPropertyDictionary(this IEdmModel edmModel,
             return null;
         }
 
+        /// <summary>
+        /// Gets the instance annotation container property info.
+        /// </summary>
+        /// <param name="edmModel">The Edm model.</param>
+        /// <param name="edmType">The Edm type.</param>
+        /// <returns>The instance annotation container property info.</returns>
+        public static PropertyInfo GetInstanceAnnotationsContainer(this IEdmModel edmModel, IEdmStructuredType edmType)
+        {
+            if (edmModel == null)
+            {
+                throw Error.ArgumentNull(nameof(edmModel));
+            }
+
+            if (edmType == null)
+            {
+                throw Error.ArgumentNull(nameof(edmType));
+            }
+
+            InstanceAnnotationContainerAnnotation annotation =
+                edmModel.GetAnnotationValue<InstanceAnnotationContainerAnnotation>(edmType);
+            if (annotation != null)
+            {
+                return annotation.PropertyInfo;
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Gets the model name.
         /// </summary>

src/Microsoft.AspNetCore.OData/Edm/EdmModelExtensions.cs

@@ -8,11 +8,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security.AccessControl;
 using Microsoft.AspNetCore.OData.Formatter.Deserialization;
+using Microsoft.AspNetCore.OData.Formatter.Wrapper;
 using Microsoft.AspNetCore.OData.Routing.Template;
 using Microsoft.OData;
 using Microsoft.OData.Edm;
+using Microsoft.OData.Edm.Csdl;
 using Microsoft.OData.Edm.Validation;
+using Microsoft.OData.Edm.Vocabularies;
 using Microsoft.OData.UriParser;
 
 namespace Microsoft.AspNetCore.OData.Edm
@@ -61,32 +65,36 @@ public static IEdmCollectionTypeReference ResolveResourceSetType(this IEdmModel
         /// Resolve the type reference from the type name of <see cref="ODataResourceBase"/>
         /// </summary>
         /// <param name="model">The Edm model.</param>
-        /// <param name="resource">The given resource.</param>
+        /// <param name="resourceWrapper">The given resource wrapper.</param>
         /// <returns>The resolved type.</returns>
-        public static IEdmStructuredTypeReference ResolveResourceType(this IEdmModel model, ODataResourceBase resource)
+        public static IEdmStructuredTypeReference ResolveResourceType(this IEdmModel model, ODataResourceWrapper resourceWrapper)
         {
             if (model == null)
             {
                 throw Error.ArgumentNull(nameof(model));
             }
 
-            if (resource == null)
+            if (resourceWrapper == null)
             {
-                throw Error.ArgumentNull(nameof(resource));
+                throw Error.ArgumentNull(nameof(resourceWrapper));
             }
 
+            string typeName = resourceWrapper.IsResourceValue ?
+                resourceWrapper.ResourceValue.TypeName :
+                resourceWrapper.Resource.TypeName;
+
             IEdmStructuredTypeReference resourceType;
-            if (string.IsNullOrEmpty(resource.TypeName) ||
-                string.Equals(resource.TypeName, "Edm.Untyped", StringComparison.OrdinalIgnoreCase))
+            if (string.IsNullOrEmpty(typeName) ||
+                string.Equals(typeName, "Edm.Untyped", StringComparison.OrdinalIgnoreCase))
             {
                 resourceType = EdmUntypedStructuredTypeReference.NullableTypeReference;
             }
             else
             {
-                IEdmStructuredType actualType = model.FindType(resource.TypeName) as IEdmStructuredType;
+                IEdmStructuredType actualType = model.FindType(typeName) as IEdmStructuredType;
                 if (actualType == null)
                 {
-                    throw new ODataException(Error.Format(SRResources.ResourceTypeNotInModel, resource.TypeName));
+                    throw new ODataException(Error.Format(SRResources.ResourceTypeNotInModel, typeName));
                 }
 
                 if (actualType is IEdmEntityType actualEntityType)
@@ -102,6 +110,51 @@ public static IEdmStructuredTypeReference ResolveResourceType(this IEdmModel mod
             return resourceType;
         }
 
+        /// <summary>
+        /// Resolve the term using the annotation identifier.
+        /// </summary>
+        /// <param name="model">The Edm model.</param>
+        /// <param name="annotationIdentifier"> It consists of the namespace or alias of the schema that defines the term, followed by a dot (.),
+        /// followed by the name of the term, optionally followed by a hash (#) and a qualifier.</param>
+        /// <returns>The resolved term or null if not found.</returns>
+        public static IEdmTerm ResolveTerm(this IEdmModel model, string annotationIdentifier)
+        {
+            if (model == null)
+            {
+                throw Error.ArgumentNull(nameof(model));
+            }
+
+            string[] identifier = annotationIdentifier.Split('#');
+
+            IEdmTerm term = model.FindTerm(identifier[0]);
+            if (term != null)
+            {
+                return term;
+            }
+
+            // TODO: Let's support namespace alias when we get requirement and ODL publics 'ReplaceAlias' extension method.
+            // identifier = model.ReplaceAlias(identifier);
+
+            string termName = identifier[0];
+            var terms = model.SchemaElements.OfType<IEdmTerm>()
+                .Where(e => string.Equals(termName, e.FullName(), StringComparison.OrdinalIgnoreCase));
+
+            foreach (var refModels in model.ReferencedModels)
+            {
+                var refedTerms = refModels.SchemaElements.OfType<IEdmTerm>()
+                    .Where(e => string.Equals(termName, e.FullName(), StringComparison.OrdinalIgnoreCase));
+
+                terms = terms.Concat(refedTerms);
+            }
+
+            if (terms.Count() > 1)
+            {
+                throw new ODataException(Error.Format(SRResources.AmbiguousTypeNameFound, termName));
+            }
+
+            return terms.SingleOrDefault();
+        }
+
         /// <summary>
         /// Get all property names for the given structured type.
         /// </summary>

src/Microsoft.AspNetCore.OData/Edm/EdmUntypedHelpers.cs

@@ -11,8 +11,13 @@ namespace Microsoft.AspNetCore.OData.Edm
 {
     internal class EdmUntypedHelpers
     {
+        // Collection(Edm.Untyped) for resource set
         public readonly static EdmCollectionTypeReference NullableUntypedCollectionReference
             = new EdmCollectionTypeReference(
                 new EdmCollectionType(EdmUntypedStructuredTypeReference.NullableTypeReference));
+
+        // Collection(Edm.Untyped) for collection of (Primitive, enum)
+        public readonly static EdmCollectionTypeReference NullablePrimitiveUntypedCollectionReference
+            = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetUntyped()));
     }
 }

src/Microsoft.AspNetCore.OData/Extensions/HttpRequestExtensions.cs

@@ -26,6 +26,8 @@ namespace Microsoft.AspNetCore.OData.Extensions
     /// </summary>
     public static class HttpRequestExtensions
     {
+        private static readonly string ODataInstanceAnnotationContainerKey = "odataInstanceAnnotation_14802D58-69EF-4B28-9BDC-963D3648F06A";
+
         /// <summary>
         /// Returns the <see cref="IODataFeature"/> from the DI container.
         /// </summary>
@@ -86,6 +88,42 @@ public static IEdmModel GetModel(this HttpRequest request)
             return request.ODataFeature().Model;
         }
 
+        /// <summary>
+        /// Set the top-level instance annotations for the request.
+        /// </summary>
+        /// <param name="request">The <see cref="HttpRequest"/> instance to extend.</param>
+        /// <param name="instanceAnnotations">The instance annotations</param>
+        public static HttpRequest SetInstanceAnnotations(this HttpRequest request, IDictionary<string, object> instanceAnnotations)
+        {
+            IODataFeature odataFeature = request.ODataFeature();
+
+            // The last wins.
+            odataFeature.RoutingConventionsStore[ODataInstanceAnnotationContainerKey] = instanceAnnotations;
+
+            return request;
+        }
+
+        /// <summary>
+        /// Get the top-level instance annotations for the request.
+        /// </summary>
+        /// <param name="request">The <see cref="HttpRequest"/> instance to extend.</param>
+        /// <returns>null or top-level instance annotations.</returns>
+        public static IDictionary<string, object> GetInstanceAnnotations(this HttpRequest request)
+        {
+            if (request == null)
+            {
+                return null;
+            }
+
+            IODataFeature odataFeature = request.ODataFeature();
+            if (!odataFeature.RoutingConventionsStore.TryGetValue(ODataInstanceAnnotationContainerKey, out object annotations))
+            {
+                return null;
+            }
+
+            return annotations as IDictionary<string, object>;
+        }
+
         /// <summary>
         /// Gets the <see cref="TimeZoneInfo"/> setting.
         /// </summary>