ApplicationContextManagerBlazor.cs

Go to the documentation of this file.

#if NET5_0_OR_GREATER
//-----------------------------------------------------------------------
// <copyright file="ApplicationContextManager.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Application context manager that uses HttpContextAccessor</summary>
//-----------------------------------------------------------------------
using Csla.Core;
using Microsoft.AspNetCore.Components.Authorization;
using System;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading.Tasks;
 
namespace Csla.AspNetCore.Blazor
{
  public class ApplicationContextManagerBlazor : IContextManager, IDisposable
  {
    private ContextDictionary LocalContext { get; set; }
    private ContextDictionary ClientContext { get; set; }
    private IPrincipal CurrentPrincipal { get; set; }
    private readonly ClaimsPrincipal UnauthenticatedPrincipal = new();
    private bool disposedValue;
 
    protected AuthenticationStateProvider AuthenticationStateProvider { get; private set; }
 
    public ApplicationContext ApplicationContext { get; set; }
 
    protected ActiveCircuitState ActiveCircuitState { get; private set; }
 
    public ApplicationContextManagerBlazor(AuthenticationStateProvider authenticationStateProvider, ActiveCircuitState activeCircuitState)
    {
      AuthenticationStateProvider = authenticationStateProvider;
      ActiveCircuitState = activeCircuitState;
      CurrentPrincipal = UnauthenticatedPrincipal;
      AuthenticationStateProvider.AuthenticationStateChanged += AuthenticationStateProvider_AuthenticationStateChanged;
      InitializeUser();
    }
 
    private void InitializeUser()
    {
      Task<AuthenticationState> task = default;
      try
      {
        task = AuthenticationStateProvider.GetAuthenticationStateAsync();
      }
      catch (InvalidOperationException ex)
      {
        task = Task.FromResult(new AuthenticationState((ClaimsPrincipal)UnauthenticatedPrincipal));
        string message = ex.Message;
        if (message.Contains(nameof(AuthenticationStateProvider.GetAuthenticationStateAsync))
            && message.Contains(nameof(IHostEnvironmentAuthenticationStateProvider.SetAuthenticationState)))
        {
          SetHostPrincipal(task);
        }
        else
        {
          throw;
        }
      }
      AuthenticationStateProvider_AuthenticationStateChanged(task);
    }
 
    private void AuthenticationStateProvider_AuthenticationStateChanged(Task<AuthenticationState> task)
    {
      if (task is null)
      {
        CurrentPrincipal = UnauthenticatedPrincipal;
      }
      else
      {
        task.ContinueWith((t) =>
        {
          if (task.IsCompletedSuccessfully && task.Result != null)
            CurrentPrincipal = task.Result.User;
          else
            CurrentPrincipal = UnauthenticatedPrincipal;
        });
      }
    }
 
    public bool IsValid
    {
      get { return ActiveCircuitState.CircuitExists; }
    }
 
    public bool IsStatefulContext => true;
 
    public IPrincipal GetUser()
    {
      return CurrentPrincipal;
    }
 
    public virtual void SetUser(IPrincipal principal)
    {
      if (!ReferenceEquals(CurrentPrincipal, principal))
      {
        if (principal is ClaimsPrincipal claimsPrincipal)
        {
          CurrentPrincipal = principal;
          SetHostPrincipal(Task.FromResult(new AuthenticationState(claimsPrincipal)));
        }
        else
        {
          throw new ArgumentException("typeof(principal) != ClaimsPrincipal");
        }
      }
    }
 
    private void SetHostPrincipal(Task<AuthenticationState> task)
    {
      if (AuthenticationStateProvider is IHostEnvironmentAuthenticationStateProvider hostProvider)
        hostProvider.SetAuthenticationState(task);
    }
 
    public ContextDictionary GetLocalContext()
    {
      if (LocalContext == null)
        LocalContext = new ContextDictionary();
      return LocalContext;
    }
 
    public void SetLocalContext(ContextDictionary localContext)
    {
      LocalContext = localContext;
    }
 
    public ContextDictionary GetClientContext(ApplicationContext.ExecutionLocations executionLocation)
    {
      if (ClientContext == null)
        ClientContext = new ContextDictionary();
      return ClientContext;
    }
 
    public void SetClientContext(ContextDictionary clientContext, ApplicationContext.ExecutionLocations executionLocation)
    {
      ClientContext = clientContext;
    }
 
    protected virtual void Dispose(bool disposing)
    {
      if (!disposedValue)
      {
        if (disposing)
        {
          AuthenticationStateProvider.AuthenticationStateChanged -= AuthenticationStateProvider_AuthenticationStateChanged;
        }
        disposedValue = true;
      }
    }
 
    public void Dispose()
    {
      // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
      Dispose(disposing: true);
      GC.SuppressFinalize(this);
    }
  }
}
#endif