Merge pull request #367 from microsoftgraph/middlewareoptions

Request Context With Middleware Options

Author: MIchaelMainer

src/Microsoft.Graph.Core/CoreConstants.cs

@@ -2,6 +2,8 @@
 //  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
 // ------------------------------------------------------------------------------
 
+using System;
+
 namespace Microsoft.Graph
 {
     /// <summary>
@@ -33,6 +35,12 @@ public static class Headers
 
             /// Throw-site header
             public const string ThrowSiteHeaderName = "X-ThrowSite";
+
+            /// Client Request Id
+            public const string ClientRequestId = "client-request-id";
+
+            /// Feature Flag
+            public const string FeatureFlag = "FeatureFlag";
         }
 
         /// <summary>

src/Microsoft.Graph.Core/Extensions/BaseRequestExtensions.cs

@@ -0,0 +1,133 @@
+// ------------------------------------------------------------------------------
+//  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
+// ------------------------------------------------------------------------------
+
+namespace Microsoft.Graph
+{
+    using System;
+    using System.Net.Http;
+
+    /// <summary>
+    /// Extension methods for <see cref="BaseRequest"/>
+    /// </summary>
+    public static class BaseRequestExtensions
+    {
+
+        /// <summary>
+        /// Sets the default authentication provider to the default Authentication Middleware Handler for this request.
+        /// This only works with the default authentication handler.
+        /// If you use a custom authentication handler, you have to handle it's retreival in your implementation.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="baseRequest">The <see cref="BaseRequest"/> for the request.</param>
+        /// <returns></returns>
+        internal static T WithDefaultAuthProvider<T>(this T baseRequest) where T : IBaseRequest
+        {
+            string authOptionKey = typeof(AuthenticationHandlerOption).ToString();
+            if (baseRequest.MiddlewareOptions.ContainsKey(authOptionKey))
+            {
+                (baseRequest.MiddlewareOptions[authOptionKey] as AuthenticationHandlerOption).AuthenticationProvider = baseRequest.Client.AuthenticationProvider;
+            }
+            else
+            {
+                baseRequest.MiddlewareOptions.Add(authOptionKey, new AuthenticationHandlerOption { AuthenticationProvider = baseRequest.Client.AuthenticationProvider });
+            }
+            return baseRequest;
+        }
+
+        /// <summary>
+        /// Sets the PerRequestAuthProvider delegate handler to the default Authentication Middleware Handler to authenticate a single request.
+        /// The PerRequestAuthProvider delegate handler must be set to the GraphServiceClient instance before using this extension method otherwise, it defaults to the default authentication provider.
+        /// This only works with the default authentication handler.
+        /// If you use a custom authentication handler, you have to handle it's retreival in your implementation.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="baseRequest">The <see cref="BaseRequest"/> for the request.</param>
+        /// <returns></returns>
+        public static T WithPerRequestAuthProvider<T>(this T baseRequest) where T : IBaseRequest
+        {
+            if (baseRequest.Client.PerRequestAuthProvider != null)
+            {
+                string authOptionKey = typeof(AuthenticationHandlerOption).ToString();
+                if (baseRequest.MiddlewareOptions.ContainsKey(authOptionKey))
+                {
+                    (baseRequest.MiddlewareOptions[authOptionKey] as AuthenticationHandlerOption).AuthenticationProvider = baseRequest.Client.PerRequestAuthProvider();
+                }
+                else
+                {
+                    baseRequest.MiddlewareOptions.Add(authOptionKey, new AuthenticationHandlerOption { AuthenticationProvider = baseRequest.Client.PerRequestAuthProvider() });
+                }
+            }
+            return baseRequest;
+        }
+
+        /// <summary>
+        /// Sets a ShouldRetry <see cref="Func{HttpResponseMessage, Boolean}"/> delegate to the default Retry Middleware Handler for this request.
+        /// This only works with the default Retry Middleware Handler.
+        /// If you use a custom Retry Middleware Handler, you have to handle it's retreival in your implementation.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="baseRequest">The <see cref="BaseRequest"/> for the request.</param>
+        /// <param name="shouldRetry">A <see cref="Func{HttpResponseMessage, Boolean}"/> for the request.</param>
+        /// <returns></returns>
+        public static T WithShouldRetry<T>(this T baseRequest, Func<HttpResponseMessage, bool> shouldRetry) where T : IBaseRequest
+        {
+            string retryOptionKey = typeof(RetryHandlerOption).ToString();
+            if (baseRequest.MiddlewareOptions.ContainsKey(retryOptionKey))
+            {
+                (baseRequest.MiddlewareOptions[retryOptionKey] as RetryHandlerOption).ShouldRetry = shouldRetry;
+            }
+            else
+            {
+                baseRequest.MiddlewareOptions.Add(retryOptionKey, new RetryHandlerOption { ShouldRetry = shouldRetry });
+            }
+            return baseRequest;
+        }
+
+        /// <summary>
+        /// Sets the maximum number of retries to the default Retry Middleware Handler for this request.
+        /// This only works with the default Retry Middleware Handler.
+        /// If you use a custom Retry Middleware Handler, you have to handle it's retreival in your implementation.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="baseRequest">The <see cref="BaseRequest"/> for the request.</param>
+        /// <param name="maxRetry">The maxRetry for the request.</param>
+        /// <returns></returns>
+        public static T WithMaxRetry<T>(this T baseRequest, int maxRetry) where T : IBaseRequest
+        {
+            string retryOptionKey = typeof(RetryHandlerOption).ToString();
+            if (baseRequest.MiddlewareOptions.ContainsKey(retryOptionKey))
+            {
+                (baseRequest.MiddlewareOptions[retryOptionKey] as RetryHandlerOption).MaxRetry = maxRetry;
+            }
+            else
+            {
+                baseRequest.MiddlewareOptions.Add(retryOptionKey, new RetryHandlerOption { MaxRetry = maxRetry });
+            }
+            return baseRequest;
+        }
+
+        /// <summary>
+        /// Sets the maximum number of redirects to the default Redirect Middleware Handler for this request.
+        /// This only works with the default Redirect Middleware Handler.
+        /// If you use a custom Redirect Middleware Handler, you have to handle it's retreival in your implementation.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="baseRequest">The <see cref="BaseRequest"/> for the request.</param>
+        /// <param name="maxRedirects">Maximum number of redirects allowed for the request</param>
+        /// <returns></returns>
+        public static T WithMaxRedirects<T>(this T baseRequest, int maxRedirects) where T : IBaseRequest
+        {
+            string redirectOptionKey = typeof(RedirectHandlerOption).ToString();
+            if (baseRequest.MiddlewareOptions.ContainsKey(redirectOptionKey))
+            {
+                (baseRequest.MiddlewareOptions[redirectOptionKey] as RedirectHandlerOption).MaxRedirects = maxRedirects;
+            }
+            else
+            {
+                baseRequest.MiddlewareOptions.Add(redirectOptionKey, new RedirectHandlerOption { MaxRedirects = maxRedirects });
+            }
+            return baseRequest;
+        }
+    }
+}

src/Microsoft.Graph.Core/Extensions/HttpClientExtensions.cs

@@ -0,0 +1,16 @@
+// ------------------------------------------------------------------------------
+//  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
+// ------------------------------------------------------------------------------
+
+namespace Microsoft.Graph
+{
+    using System.Net.Http;
+
+    internal static class HttpClientExtensions
+    {
+        internal static void SetFeatureFlags(this HttpClient httpClient, FeatureFlag featureFlag)
+        {
+            httpClient.DefaultRequestHeaders.Add(CoreConstants.Headers.FeatureFlag, featureFlag.ToString());
+        }
+    }
+}

src/Microsoft.Graph.Core/Extensions/RequestExtensions.cs renamed to src/Microsoft.Graph.Core/Extensions/HttpRequestMessageExtensions.cs

@@ -4,13 +4,16 @@
 
 namespace Microsoft.Graph
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using System.Net.Http;
     using System.Threading.Tasks;
 
     /// <summary>
     /// Contains extension methods for <see cref="HttpRequestMessage"/>
     /// </summary>
-    internal static class RequestExtensions
+    public static class HttpRequestMessageExtensions
     {
         /// <summary>
         /// Checks the HTTP request's content to determine if it's buffered or streamed content.
@@ -29,6 +32,23 @@ internal static bool IsBuffered(this HttpRequestMessage httpRequestMessage)
             return true;
         }
 
+        /// <summary>
+        /// Get's feature request header value from the incoming <see cref="HttpRequestMessage"/>
+        /// </summary>
+        /// <param name="httpRequestMessage">The <see cref="HttpRequestMessage"/> object</param>
+        /// <returns></returns>
+        internal static FeatureFlag GetFeatureFlags(this HttpRequestMessage httpRequestMessage)
+        {
+            httpRequestMessage.Headers.TryGetValues(CoreConstants.Headers.FeatureFlag, out IEnumerable<string> flags);
+
+            if (!Enum.TryParse(flags?.FirstOrDefault(), out FeatureFlag featureFlag))
+            {
+                featureFlag = FeatureFlag.None;
+            }
+
+            return featureFlag;
+        }
+
         /// <summary>
         /// Create a new HTTP request by copying previous HTTP request's headers and properties from response's request message.
         /// </summary>
@@ -59,5 +79,38 @@ internal static async Task<HttpRequestMessage> CloneAsync(this HttpRequestMessag
 
             return newRequest;
         }
+
+        /// <summary>
+        /// Gets a <see cref="GraphRequestContext"/> from <see cref="HttpRequestMessage"/>
+        /// </summary>
+        /// <param name="httpRequestMessage">The <see cref="HttpRequestMessage"/> representation of the request.</param>
+        /// <returns></returns>
+        public static GraphRequestContext GetRequestContext(this HttpRequestMessage httpRequestMessage)
+        {
+            GraphRequestContext requestContext = new GraphRequestContext();
+            if (httpRequestMessage.Properties.TryGetValue(typeof(GraphRequestContext).ToString(), out var requestContextObject))
+            {
+                requestContext = (GraphRequestContext)requestContextObject;
+            }
+            return requestContext;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="IMiddlewareOption"/> from <see cref="HttpRequestMessage"/>
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="httpRequestMessage">The <see cref="HttpRequestMessage"/> representation of the request.</param>
+        /// <returns>A middleware option</returns>
+        public static T GetMiddlewareOption<T>(this HttpRequestMessage httpRequestMessage) where T : IMiddlewareOption
+        {
+            IMiddlewareOption option = null;
+            GraphRequestContext requestContext = httpRequestMessage.GetRequestContext();
+            if (requestContext.MiddlewareOptions != null)
+            {
+                requestContext.MiddlewareOptions.TryGetValue(typeof(T).ToString(), out option);
+            }
+            return (T)option;
+        }
+
     }
 }

src/Microsoft.Graph.Core/Requests/BaseClient.cs

@@ -4,7 +4,7 @@
 
 namespace Microsoft.Graph
 {
-    using System.Threading.Tasks;
+    using System;
 
     /// <summary>
     /// A default <see cref="IBaseClient"/> implementation.
@@ -25,9 +25,15 @@ public BaseClient(
             IHttpProvider httpProvider = null)
         {
             this.BaseUrl = baseUrl;
-            this.HttpProvider = httpProvider ?? new HttpProvider(authenticationProvider, new Serializer());
+            this.AuthenticationProvider = authenticationProvider;
+            this.HttpProvider = httpProvider ?? new HttpProvider(new Serializer());
         }
 
+        /// <summary>
+        /// Gets the <see cref="IAuthenticationProvider"/> for authenticating requests.
+        /// </summary>
+        public IAuthenticationProvider AuthenticationProvider { get; set; }
+
         /// <summary>
         /// Gets or sets the base URL for requests of the client.
         /// </summary>
@@ -54,5 +60,10 @@ public string BaseUrl
         /// Gets the <see cref="IHttpProvider"/> for sending HTTP requests.
         /// </summary>
         public IHttpProvider HttpProvider { get; private set; }
+
+        /// <summary>
+        /// Gets or Sets the <see cref="IAuthenticationProvider"/> for authenticating a single HTTP requests. 
+        /// </summary>
+        public Func<IAuthenticationProvider> PerRequestAuthProvider { get; set; }
     }
 }