Initial Commit ...

2024-01-25 04:44:02 +03:30
commit a8e257b855
36 changed files with 6645 additions and 0 deletions
@@ -0,0 +1,182 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using xCommons.Constants;
+using xCommons.Extensions;
+using xIdentityModels.Extensions;
+using xIdentityService.Interfaces;
+
+namespace xIdentityService.Middlewares {
+    public partial class XIdentityTokenRefresherMiddleware {
+        //
+        #region Properties ...
+        private readonly ILogger logger;
+        private readonly RequestDelegate next;
+        private readonly IXTokenProvider tokenProvider;
+        private readonly IXIdentityProvider identityProvider;
+        #endregion
+
+        //
+        #region Constructor ...
+        public XIdentityTokenRefresherMiddleware (
+            RequestDelegate next,
+            ILoggerFactory loggerFactory,
+            IXTokenProvider tokenProvider,
+            IXIdentityProvider identityProvider
+        ) {
+            //
+            this.next = next;
+            this.tokenProvider = tokenProvider;
+            this.identityProvider = identityProvider;
+            this.logger = loggerFactory
+                .CreateLogger<XIdentityTokenRefresherMiddleware> ();
+        }
+        #endregion
+
+        //
+        #region Actions ...
+        public async Task Invoke (HttpContext context) {
+            //
+            // Handle Request ...
+            await HandleRequest (context);
+
+            //
+            // Do Main Task ...
+            try {
+                await next.Invoke (context);
+            } catch (Exception ex) {
+                logger.LogError ($"Error: {ex.Message}");
+            }
+
+            //
+            // Handle Response ...
+            await HandleResponse (context);
+        }
+        #endregion
+
+        //
+        #region Private ...
+        private async Task HandleRequest (HttpContext context) {
+            //
+            // Log ...
+            logger.LogInformation ($"Start Process Request ...");
+
+            //
+            // Check Access Token ...
+            var hasAccessToken = HasAccessToken (context);
+            if (!hasAccessToken) {
+                return;
+            }
+
+            //
+            // Check Access Token ...
+            var accessToken = GetAccessToken (context);
+            var isExists = await tokenProvider
+                .IsTokenExists (accessToken);
+            if (!isExists) {
+                return;
+            }
+
+            //
+            // Try Check is Refreshable ...
+            var tokens = await tokenProvider
+                .RetrieveToken (accessToken);
+            if (tokens.IsNull ()) {
+                return;
+            }
+
+            //
+            // Check is Expired or Refreshable ...
+            var isRefreshable = tokens.IsRefreshable ();
+            if (!isRefreshable) {
+                return;
+            }
+
+            //
+            // Refresh Token ...
+            var refreshedTokens = await identityProvider
+                .RefreshTokens (tokens);
+            if (refreshedTokens.IsNull ()) {
+                return;
+            }
+
+            //
+            // Set Refreshed AccessToken to Request ...
+            context
+                .Request
+                .Headers[XAuthorization.Header] =
+                $"{XAuthorization.TokenIdentifier}{refreshedTokens.AccessToken}";
+        }
+
+        private async Task HandleResponse (HttpContext context) {
+            //
+            // Log ...
+            logger.LogInformation ($"Start Process Response ...");
+
+            //
+            await Task.Run (() => { });
+        }
+
+        private bool HasAccessToken (HttpContext context) {
+            //
+            // Check Headers ...
+            if (context.IsNull () ||
+                context.Request.IsNull () ||
+                context.Request.Headers.IsNull ()) {
+                return false;
+            }
+
+            //
+            var result = context
+                .Request
+                .Headers
+                .ContainsKey (
+                    XAuthorization.Header
+                );
+
+            //
+            return result;
+        }
+
+        private string GetAccessToken (HttpContext context) {
+            //
+            var hasAccessToken = HasAccessToken (context);
+            if (!hasAccessToken) {
+                return string.Empty;
+            }
+
+            //
+            // Get Result ...
+            var result = context
+                .Request
+                .Headers[
+                    XAuthorization.Header
+                ];
+            result = result
+                .ToString ()
+                .Replace (
+                    XAuthorization.TokenIdentifier,
+                    ""
+                );
+
+            //
+            return result;
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Provide all DI Requirements for XIdentityTokenRefresher Middleware
+    /// </summary>
+    public static class XIdentityTokenRefresherDIHelper {
+        /// <summary>
+        /// Use XTokenValidator Middleware
+        /// </summary>
+        /// <param name="app"></param>
+        public static void UseXIdentityTokenRefresher (this IApplicationBuilder app) {
+            app.UseMiddleware<XIdentityTokenRefresherMiddleware> ();
+        }
+    }
+}