Initial ...

Controllers/Base/XIBaseController.cs

@@ -0,0 +1,269 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using xCommons.Configurations;
+using xCommons.Constants;
+using xCommons.Controllers;
+using xCommons.Extensions;
+using xCommons.Providers;
+using xExceptions.Constants;
+using xIdentityModels.Constants;
+using xIdentityModels.Models;
+using xIds.Interfaces;
+
+namespace xIds.Controllers.Base
+{
+    public abstract class XIBaseController : XBaseController
+    {
+        public IXIdentityManager IdentityManager { get; }
+
+        protected XIBaseController(
+            ILogger logger,
+            XAppConfiguration appConfiguration,
+            IXIdentityManager identityManager,
+            XValidationProvider validationProvider
+        ) : base(
+            logger,
+            appConfiguration,
+            validationProvider
+        )
+        {
+            IdentityManager = identityManager;
+        }
+
+        //
+        #region User Handlers NonActions ...
+        /// <summary>
+        /// Retrieve User Identifier Base on XActionRequest
+        /// </summary>
+        /// <param name="model"></param>
+        /// <param name="forceNotNull"></param>
+        /// <param name="excludes"></param>
+        /// <returns></returns>
+        [NonAction]
+        public string GetUserSelectByParam(
+            XActionRequest model,
+            bool forceNotNull = true,
+            ICollection<XUserSelectBy> excludes = null)
+        {
+            //
+            // Validate Args ...
+            ValidationProvider.NotNull(model);
+
+            //
+            var result = IdentityManager.GetUserSelectByParam(
+                model,
+                forceNotNull,
+                excludes);
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Retrieve Access Token
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<string> GetAccessToken()
+        {
+            //
+            var accessToken = Request.Headers[XAuthorization.Header].ToString();
+            if (accessToken.IsNullOrEmpty())
+            {
+                accessToken = await HttpContext.GetTokenAsync(XAuthorization.AccessToken);
+            }
+
+            //
+            if (accessToken
+                .ToNormalString()
+                .Contains(XAuthorization.TokenIdentifier.ToNormalString()))
+            {
+                accessToken = accessToken.Remove(0, XAuthorization.TokenIdentifier.Length);
+            }
+
+            //
+            Logger.LogInformation($"Token: {accessToken}");
+            return accessToken;
+        }
+
+        /// <summary>
+        /// Retrieve Refresh Token
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<string> GetRefreshToken()
+        {
+            //
+            var refreshToken = Request.Headers[XAuthorization.RefreshToken].ToString();
+            if (refreshToken.IsNullOrEmpty())
+            {
+                refreshToken = await HttpContext.GetTokenAsync(XAuthorization.RefreshToken);
+            }
+
+            //
+            Logger.LogInformation($"Refresh Token: {refreshToken}");
+            return refreshToken;
+        }
+
+        /// <summary>
+        /// Retrieve Access Token Expiration Date
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<long> GetTokenExpiresAt()
+        {
+            //
+            var expiresAtStr = Request.Headers[XAuthorization.ExpiresAt].ToString();
+            if (expiresAtStr.IsNullOrEmpty())
+            {
+                expiresAtStr = await HttpContext.GetTokenAsync(XAuthorization.ExpiresAt);
+            }
+
+            //
+            var expiresAt = expiresAtStr.ConvertTo<long>();
+
+            //
+            Logger.LogInformation($"Token ExpiresAt: {expiresAtStr}");
+            return expiresAt;
+        }
+
+        /// <summary>
+        /// Retrieve All Required Tokens
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<XLoginResponse> RetrieveTokensAsXLoginResponse()
+        {
+            //
+            var accessToken = await GetAccessToken();
+            var refreshToken = await GetRefreshToken();
+            var expiresAt = await GetTokenExpiresAt();
+
+            //
+            return new XLoginResponse
+            {
+                AccessToken = accessToken,
+                RefreshToken = refreshToken,
+                ExpiresAt = expiresAt
+            };
+        }
+
+        /// <summary>
+        /// Retrieve All Required Tokens
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<XTokenResponse> RetrieveTokensAsXTokenResponse()
+        {
+            //
+            var accessToken = await GetAccessToken();
+            var refreshToken = await GetRefreshToken();
+            var expiresAt = await GetTokenExpiresAt();
+
+            //
+            return new XTokenResponse
+            {
+                AccessToken = accessToken,
+                RefreshToken = refreshToken,
+                ExpiresAt = expiresAt
+            };
+        }
+
+        /// <summary>
+        /// Retrive UserInfo
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<XUserClaimsInfoDto> GetUserInfo()
+        {
+            //
+            var claims = User.Claims ?? null;
+            if (!claims.HasChild())
+            {
+                return null;
+            }
+
+            var xTokens = await RetrieveTokensAsXTokenResponse();
+            var result = new XUserClaimsInfoDto(
+                xTokens.AccessToken,
+                xTokens.RefreshToken,
+                xTokens.ExpiresAt,
+                User.Claims
+            );
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Validate User Authenticated and Retrieve User Info
+        /// </summary>
+        /// <returns></returns>
+        [NonAction]
+        public async Task<XUserClaimsInfoDto> ValidateAndGetUserInfo()
+        {
+            //
+            if (!User.Identity.IsAuthenticated)
+            {
+                XException.NotAuthorized.Throw();
+            }
+
+            //
+            var result = await GetUserInfo();
+            if (result.IsNull())
+            {
+                XException.NotAuthorized.Throw();
+            }
+
+            //
+            return result;
+        }
+        #endregion
+
+        //
+        #region NonActions ...
+        /// <summary>
+        /// Convert an Exception to Propper Error Result
+        /// </summary>
+        /// <param name="ex"></param>
+        /// <returns></returns>
+        [NonAction]
+        public new ActionResult GetExceptionActionResult(Exception ex)
+        {
+            //
+            var exception = GetExceptionResult(ex);
+            var error = ex.Message.ToXError();
+
+            //
+            Logger.LogError($"exception: {exception}, error: {error}");
+
+            //
+            try
+            {
+                var xError = exception.Message.ToXError();
+                var xException = (XException)xError.Id;
+
+                //
+                switch (xException)
+                {
+                    //
+                    case XException.NotFound:
+                        return NotFound(error);
+
+                    //
+                    case XException.NotAuthorized:
+                        return Unauthorized(error);
+                }
+            }
+            catch { }
+
+            //
+            return BadRequest(error);
+        }
+        #endregion
+    }
+}