Csla.Blazor.WebAssembly/ApplicationContextManager.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <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.Blazor.WebAssembly
{
  public class ApplicationContextManager : 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; }
 
    public ApplicationContextManager(AuthenticationStateProvider authenticationStateProvider)
    {
      AuthenticationStateProvider = authenticationStateProvider;
      CurrentPrincipal = UnauthenticatedPrincipal;
      AuthenticationStateProvider.AuthenticationStateChanged += AuthenticationStateProvider_AuthenticationStateChanged;
      InitializeUser();
    }
 
    private void InitializeUser()
    {
      AuthenticationStateProvider_AuthenticationStateChanged(AuthenticationStateProvider.GetAuthenticationStateAsync());
    }
 
    private void AuthenticationStateProvider_AuthenticationStateChanged(Task<AuthenticationState> task)
    {
      task.ContinueWith((t) =>
      {
        if (task.IsCompletedSuccessfully && task.Result != null)
          CurrentPrincipal = task.Result.User;
        else
          CurrentPrincipal = UnauthenticatedPrincipal;
      });
    }
 
    public bool IsValid
    {
      get { return true; }
    }
 
    public bool IsStatefulContext => true;
 
    public IPrincipal GetUser()
    {
      return CurrentPrincipal;
    }
 
    public virtual void SetUser(IPrincipal principal)
    {
      CurrentPrincipal = principal;
    }
 
    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);
    }
  }
}