none
GetExternalLoginInfoAsync returns null mvc RRS feed

  • Question

  • I receive the following code error when trying to run my MVC application from localhost using Microsoft AD. When debugging the application I noticed that GetExternalLoginInfoAsync returns null. However, the application runs fine on the web. What am I missing? Somebody please help. I have posted my code below the error message:

    -----------------------------------
    Server Error in '/' Application.

    Object reference not set to an instance of an object.
      Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

     Exception Details: System.NullReferenceException: Object reference not set to an instance of an object.

    Source Error:

    Line 140:        {
    Line 141:            ExternalLoginInfo loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
    Line 142:            ClaimsIdentity claimsIdentity = loginInfo.ExternalIdentity;
    Line 143:            ApplicationUser applicationUser = new ApplicationUser(claimsIdentity);
    Line 144:            IdentityResult result = await UserManager.PersistAsync(applicationUser);

    ------------------------------------------------------------

    My Code

    using Microsoft.AspNet.Identity;
    using Microsoft.AspNet.Identity.EntityFramework;
    using Microsoft.AspNet.Identity.Owin;
    using Microsoft.Owin.Security;
    using Microsoft.Owin.Security.Cookies;
    using Microsoft.Owin.Security.OpenIdConnect;
    using SampleQuoteTracker.Models;
    using System;
    using System.Security.Claims;
    using System.Threading.Tasks;
    using System.Web;
    using System.Web.Mvc;
    using System.Web.Routing;
    
    
    namespace SampleQuoteTracker.Controllers
    {
        /// <summary>
        /// Provides methods for accepting and desplaying account authenication and creating new accounts.
        /// </summary>
        public class AccountController : Controller
        {
            //
            // GET: /Account/Login
            public ActionResult Login(string returnUrl)
            {
                ViewBag.Title = "Log In";
                LoginViewModel loginViewModel = new LoginViewModel()
                {
                    ReturnUrl = returnUrl
                };
                return View(loginViewModel);
            }
    
            //
            // POST: /Account/Login
            [HttpPost]
            [ValidateAntiForgeryToken]
            public async Task<JsonResult> Login(LoginViewModel model)
            {
                // seed return object optimistically
                AjaxResultModel loginResult = new AjaxResultModel
                {
                    Status = "Valid",
                    ReturnUrl = GetLocalUrl(model.ReturnUrl),
                    Message = null
                };
                if (Request.IsAjaxRequest())
                {
                    if (!ModelState.IsValid)
                    {
                        loginResult.Status = "Invalid";
                        loginResult.Message = Tools.ListModelStateErrors(ModelState);
                    }
                    if (loginResult.Status == "Valid")
                    {
                        SignInStatus result = await SignInManager.PasswordSignInAsync(
                            model.Email,
                            model.Password,
                            model.RememberMe,
                            shouldLockout: false);
                        switch (result)
                        {
                            case SignInStatus.Success:
                                loginResult.Status = "Success";
                                break;
                            case SignInStatus.LockedOut:
                                loginResult.Status = "LockOut";
                                loginResult.Message = AlertMessages.AccountLockOut;
                                break;
                            case SignInStatus.Failure:
                            default:
                                loginResult.Status = "Failure";
                                loginResult.Message = AlertMessages.AuthenticationFailure;
                                break;
                        }
                    }
                }
                return Json(loginResult);
            }
    
            //
            // POST: /Account/LogOff
            [Authorize]
            [HttpPost]
            [ValidateAntiForgeryToken]
            public ActionResult LogOff()
            {
                //AuthenticationManager.SignOut();
                //return RedirectToAction("SignOutCallback");
                return null;
            }
    
            public void SignIn(string returnUrl = "/")
            {
                if (returnUrl == "/")
                {
                    returnUrl = Request.ApplicationPath;
                }
                Uri baseUri = new UriBuilder(Request.Url.Scheme, Request.Url.Host, Request.Url.Port).Uri;
                Uri uri = new Uri(baseUri, returnUrl);
                // If this action is called and the user is already authenticated,
                // it means the user is not a member of the appropriate role for
                // the controller/action requested.
                if (Request.IsAuthenticated)
                {
                    RouteValueDictionary values = RouteDataContext.RouteValuesFromUri(uri);
                    string controllerName = (string)values["controller"];
                    string actionName = (string)values["action"];
                    string errorUrl = Url.Action("Error",
                        routeValues: new
                        {
                            message = "You are not authorized to view this content",
                            controllerName,
                            actionName
                        });
                    Response.Redirect(errorUrl, true);
                }
                else
                {
                    // https://stackoverflow.com/a/21234614
                    // Activate the session before login to generate the authentication cookie correctly.
                    Session["Workaround"] = 0;
                    // Send an OpenID Connect sign-in request.
                    string externalLoginCallback = Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl });
                    AuthenticationManager.Challenge(new AuthenticationProperties { RedirectUri = externalLoginCallback },
                        OpenIdConnectAuthenticationDefaults.AuthenticationType);
                }
            }
    
            //public IAuthenticationManager AuthenticationManager
            //{
            //    get { return HttpContext.GetOwinContext().Authentication; }
    
            //}
    
            public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
            {
                ExternalLoginInfo loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
                ClaimsIdentity claimsIdentity = loginInfo.ExternalIdentity;
                ApplicationUser applicationUser = new ApplicationUser(claimsIdentity);
                IdentityResult result = await UserManager.PersistAsync(applicationUser);
                if (result.Succeeded)
                {
                    claimsIdentity = await applicationUser.GenerateUserIdentityAsync(UserManager);
                }
                AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = false }, claimsIdentity);
                return Redirect(returnUrl);
            }
    
          
            [Authorize]
            public void SignOut()
            {
                string callbackUrl = Url.Action("SignOutCallback", "Account", null, Request.Url.Scheme);
                AuthenticationProperties properties = new AuthenticationProperties { RedirectUri = callbackUrl };
    
                AuthenticationManager.SignOut(
                    properties,
                    OpenIdConnectAuthenticationDefaults.AuthenticationType,
                    CookieAuthenticationDefaults.AuthenticationType,
                    Microsoft.AspNet.Identity.DefaultAuthenticationTypes.ApplicationCookie);
            }
    
            public ActionResult Error(string message, string controllerName = "Account", string actionName = "SignIn")
            {
                Exception exception = new Exception(message);
                HandleErrorInfo handleErrorInfo = new HandleErrorInfo(exception, controllerName, actionName);
                return View("Error", handleErrorInfo);
            }
            public ActionResult SignOutCallback()
            {
                if (Request.IsAuthenticated)
                {
                    // Redirect to home page if the user is authenticated.
                    return RedirectToAction("Index", "Home");
                }
    
                return View();
            }
    
            protected override void Dispose(bool disposing)
            {
                if (disposing && UserManager != null)
                {
                    UserManager.Dispose();
                    UserManager = null;
                }
                base.Dispose(disposing);
            }
            #region Helpers
            private ApplicationSignInManager _signInManager;
            private ApplicationUserManager _userManager;
            private IAuthenticationManager _authenticationManager;
            // Used for XSRF protection when adding external logins
            private const string XsrfKey = "XsrfId";
            /// <summary>
            /// Gets a reference to the <see cref="ApplicationSignInManager"/>.
            /// </summary>
            protected ApplicationSignInManager SignInManager
            {
                get
                {
                    return _signInManager ?? HttpContext.GetOwinContext().Get<ApplicationSignInManager>();
                }
                private set { _signInManager = value; }
            }
            protected ApplicationUserManager UserManager
            {
                get
                {
                    return _userManager ?? HttpContext.GetOwinContext().GetUserManager<ApplicationUserManager>();
                }
                private set
                {
                    _userManager = value;
                }
            }
            protected IAuthenticationManager AuthenticationManager
            {
                get
                {
                    return _authenticationManager ?? HttpContext.GetOwinContext().Authentication;
                }
                private set
                {
                    _authenticationManager = value;
                }
            }
            /// <summary>
            /// Ensures the <paramref name="returnUrl"/> belongs to this application.
            /// <para>We don't want to redirect to a foreign page after authentication.</para>
            /// </summary>
            /// <param name="returnUrl">a <see cref="System.String"/> containing the page address that required authorization.</param>
            /// <returns>a <see cref="System.String"/> containing a local page address.</returns>
            private string GetLocalUrl(string returnUrl)
            {
                if (!Url.IsLocalUrl(returnUrl))
                {
                    return Url.Action("Index", "Home");
                }
                return returnUrl;
            }
            private class ChallengeResult : HttpUnauthorizedResult
            {
                public ChallengeResult(string provider, string redirectUri)
                    : this(provider, redirectUri, null)
                {
                }
    
                public ChallengeResult(string provider, string redirectUri, string userId)
                {
                    LoginProvider = provider;
                    RedirectUri = redirectUri;
                    UserId = userId;
                }
    
                public string LoginProvider { get; set; }
                public string RedirectUri { get; set; }
                public string UserId { get; set; }
    
                public override void ExecuteResult(ControllerContext context)
                {
                    var properties = new AuthenticationProperties() { RedirectUri = RedirectUri };
                    if (UserId != null)
                    {
                        properties.Dictionary[XsrfKey] = UserId;
                    }
                    context.HttpContext.GetOwinContext().Authentication.Challenge(properties, LoginProvider);
                }
            }
            private class RouteDataContext : HttpContextBase
            {
                public override HttpRequestBase Request { get; }
    
                private RouteDataContext(Uri uri)
                {
                    string url = uri.GetLeftPart(UriPartial.Path);
                    string qs = uri.GetComponents(UriComponents.Query, UriFormat.UriEscaped);
    
                    Request = new HttpRequestWrapper(new HttpRequest(null, url, qs));
                }
    
                public static RouteValueDictionary RouteValuesFromUri(Uri uri)
                {
                    return RouteTable.Routes.GetRouteData(new RouteDataContext(uri)).Values;
                }
            }
            #endregion
        }
    }

    • Moved by CoolDadTx Tuesday, December 31, 2019 7:12 PM ASP.NET related
    Tuesday, December 31, 2019 5:04 PM

All replies