Enhance UserContext and refactor codebase

- Added `AllowedTenantIds` property to `UserContext` to support multi-tenant scenarios.
- Updated `UserContextLoader` to fetch and populate `AllowedTenantIds`.
- Refactored `UserProfileState` to simplify logic, consolidate repetitive code, and improve cache handling with new helper methods.
- Removed unused `using` directives across multiple files to reduce clutter.
- Cleaned up `ApplicationDbContextFactory` and `ApplicationDbContextInitializer` by removing unnecessary code.
- Improved formatting consistency and replaced hardcoded values with constants where applicable.
- Addressed potential BOM character (``) issue introduced in several files, which may cause compatibility problems.
- Streamlined redundant comments and unused methods for better maintainability.

Author: neozhu

src/Application/Common/Interfaces/Identity/UserContext.cs

@@ -1,4 +1,4 @@
-namespace CleanArchitecture.Blazor.Application.Common.Interfaces.Identity;
+namespace CleanArchitecture.Blazor.Application.Common.Interfaces.Identity;
 
 /// <summary>
 /// Represents the current user context with essential user information.
@@ -8,6 +8,7 @@ public sealed record UserContext(
     string UserName,
     string? DisplayName = null,
     string? TenantId = null,
+    IReadOnlyList<string>? AllowedTenantIds = null,
     string? Email = null,
     IReadOnlyList<string>? Roles = null,
     string? ProfilePictureDataUrl = null,

src/Infrastructure/Configurations/AISettings.cs

@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using CleanArchitecture.Blazor.Application.Common.Interfaces;
-
 namespace CleanArchitecture.Blazor.Infrastructure.Configurations;
 
 /// <summary>

src/Infrastructure/DependencyInjection.cs

@@ -3,19 +3,12 @@
 
 using System.Reflection;
 using CleanArchitecture.Blazor.Application.Common.Constants;
-using CleanArchitecture.Blazor.Application.Common.Interfaces; // IDataSourceService
-using CleanArchitecture.Blazor.Application.Common.Models;
 using CleanArchitecture.Blazor.Application.Common.Security;
-using CleanArchitecture.Blazor.Application.Features.Identity.DTOs;
-using CleanArchitecture.Blazor.Application.Features.PicklistSets.DTOs;
-using CleanArchitecture.Blazor.Application.Features.Tenants.DTOs;
 using CleanArchitecture.Blazor.Domain.Identity;
 using CleanArchitecture.Blazor.Infrastructure.Configurations;
 using CleanArchitecture.Blazor.Infrastructure.Persistence.Interceptors;
-using CleanArchitecture.Blazor.Infrastructure.Services;
 using CleanArchitecture.Blazor.Infrastructure.Services.Circuits;
 using CleanArchitecture.Blazor.Infrastructure.Services.Gemini;
-using CleanArchitecture.Blazor.Infrastructure.Services.Identity;
 using CleanArchitecture.Blazor.Infrastructure.Services.MultiTenant;
 using MaxMind.GeoIP2;
 using Microsoft.AspNetCore.Components.Server.Circuits;

src/Infrastructure/Persistence/ApplicationDbContextFactory.cs

@@ -1,10 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CleanArchitecture.Blazor.Infrastructure.Persistence;
+namespace CleanArchitecture.Blazor.Infrastructure.Persistence;
 internal sealed class ApplicationDbContextFactory(IDbContextFactory<ApplicationDbContext> efFactory) : IApplicationDbContextFactory
 {
     public ValueTask<IApplicationDbContext> CreateAsync(CancellationToken ct = default)

src/Infrastructure/Persistence/ApplicationDbContextInitializer.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Reflection;
+using System.Reflection;
 using CleanArchitecture.Blazor.Application.Common.Constants;
 using CleanArchitecture.Blazor.Application.Common.Security;
 using CleanArchitecture.Blazor.Domain.Identity;

src/Infrastructure/Services/Identity/UserContextHubFilter.cs

@@ -1,5 +1,4 @@
-using CleanArchitecture.Blazor.Application.Common.Interfaces.Identity;
-using Microsoft.AspNetCore.SignalR;
+using Microsoft.AspNetCore.SignalR;
 
 namespace CleanArchitecture.Blazor.Infrastructure.Services.Identity;
 

src/Infrastructure/Services/Identity/UserContextLoader.cs

@@ -1,8 +1,5 @@
-using CleanArchitecture.Blazor.Application.Common.Constants;
-using CleanArchitecture.Blazor.Application.Common.Extensions;
-using CleanArchitecture.Blazor.Application.Common.Interfaces.Identity;
+using CleanArchitecture.Blazor.Application.Common.Constants;
 using CleanArchitecture.Blazor.Domain.Identity;
-using Microsoft.AspNetCore.Identity;
 using ZiggyCreatures.Caching.Fusion;
 
 namespace CleanArchitecture.Blazor.Infrastructure.Services.Identity;
@@ -60,14 +57,15 @@ public UserContextLoader(IServiceScopeFactory scopeFactory, IFusionCache fusionC
                     {
                         return null;
                     }
-
+                    var allowedTenantIds = await userManager.Users.Where(x => x.Id == user.Id).Include(x => x.TenantUsers).ThenInclude(tu => tu.Tenant).SelectMany(x => x.TenantUsers.Select(x => x.Tenant.Id)).ToListAsync();
                     var roles = await userManager.GetRolesAsync(user);
 
                     return new UserContext(
                         UserId: user.Id,
                         UserName: user.UserName ?? string.Empty,
                         DisplayName: user.DisplayName,
                         TenantId: user.TenantId,
+                        AllowedTenantIds: allowedTenantIds.AsReadOnly(),
                         Email: user.Email,
                         Roles: roles.ToList().AsReadOnly(),
                         ProfilePictureDataUrl: user.ProfilePictureDataUrl,
@@ -79,7 +77,7 @@ public UserContextLoader(IServiceScopeFactory scopeFactory, IFusionCache fusionC
                     return null;
                 }
             },
-            options:new FusionCacheEntryOptions(TimeSpan.FromHours(1)),
+            options: new FusionCacheEntryOptions(TimeSpan.FromHours(1)),
             cancellationToken
         );
     }
@@ -97,5 +95,5 @@ public void ClearUserContextCache(string userId)
         }
     }
 
-    
-} 
+
+}

src/Infrastructure/Services/Identity/UserProfileState.cs

@@ -1,31 +1,18 @@
-using CleanArchitecture.Blazor.Application.Common.Constants;
-using CleanArchitecture.Blazor.Application.Common.Interfaces.Identity;
+using CleanArchitecture.Blazor.Application.Common.Constants;
 using CleanArchitecture.Blazor.Application.Common.Security;
 using CleanArchitecture.Blazor.Application.Features.Identity.DTOs;
 using CleanArchitecture.Blazor.Domain.Identity;
-using Microsoft.AspNetCore.Identity;
-using Microsoft.Extensions.DependencyInjection;
 using ZiggyCreatures.Caching.Fusion;
 
 namespace CleanArchitecture.Blazor.Infrastructure.Services.Identity;
 
-/// <summary>
-/// Implementation of IUserProfileState following Blazor state management best practices.
-/// Uses immutable UserProfile snapshots with precise event notifications.
-/// </summary>
 public class UserProfileState : IUserProfileState, IDisposable
 {
-    // Cache refresh interval of 60 seconds
-    private TimeSpan RefreshInterval => TimeSpan.FromSeconds(60);
-
-    // Current user profile state (immutable snapshot)
+    private const int CacheRefreshSeconds = 60;
+    
     private UserProfile _currentValue = UserProfile.Empty;
     private string? _currentUserId;
-
-    // Concurrency control
     private readonly SemaphoreSlim _semaphore = new(1, 1);
-
-    // Dependencies
     private readonly IMapper _mapper;
     private readonly IFusionCache _fusionCache;
     private readonly IServiceScopeFactory _scopeFactory;
@@ -43,50 +30,25 @@ public UserProfileState(
         _logger = logger;
     }
 
-    /// <summary>
-    /// Gets the current user profile snapshot (immutable).
-    /// </summary>
     public UserProfile Value => _currentValue;
-
-    /// <summary>
-    /// Event triggered when the user profile changes.
-    /// Subscribers receive the new UserProfile snapshot.
-    /// </summary>
     public event EventHandler<UserProfile>? Changed;
 
-    /// <summary>
-    /// Ensures the user profile is initialized for the given user ID.
-    /// Only loads from database on first call or when user changes.
-    /// </summary>
     public async Task EnsureInitializedAsync(string userId, CancellationToken cancellationToken = default)
     {
-        if (string.IsNullOrWhiteSpace(userId))
-            return;
-
-        // Check if already initialized for this user
-        if (_currentUserId == userId && _currentValue != UserProfile.Empty)
+        if (string.IsNullOrWhiteSpace(userId) || (_currentUserId == userId && _currentValue != UserProfile.Empty))
             return;
 
         await _semaphore.WaitAsync(cancellationToken);
         try
         {
-            // Double-check after acquiring lock
             if (_currentUserId == userId && _currentValue != UserProfile.Empty)
                 return;
 
             var result = await LoadUserProfileFromDatabaseAsync(userId, cancellationToken);
-
-            if (result is not null)
-            {
-                var newProfile = result.ToUserProfile();
-                _currentUserId = userId;
-                SetInternal(newProfile);
-            }
-            else
-            {
-                _currentUserId = userId;
-                SetInternal(UserProfile.Empty with { UserId = userId });
-            }
+            var newProfile = result?.ToUserProfile() ?? UserProfile.Empty with { UserId = userId };
+            
+            _currentUserId = userId;
+            SetInternal(newProfile);
         }
         catch (Exception ex)
         {
@@ -99,9 +61,6 @@ public async Task EnsureInitializedAsync(string userId, CancellationToken cancel
         }
     }
 
-    /// <summary>
-    /// Refreshes the user profile by clearing cache and reloading from database.
-    /// </summary>
     public async Task RefreshAsync(CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(_currentUserId))
@@ -110,16 +69,11 @@ public async Task RefreshAsync(CancellationToken cancellationToken = default)
         await _semaphore.WaitAsync(cancellationToken);
         try
         {
-            var cacheKey = UserCacheKeys.GetCacheKey(_currentUserId, UserCacheType.Application);
-            await _fusionCache.RemoveAsync(cacheKey);
-            
+            await ClearCacheAsync(_currentUserId);
             var result = await LoadUserProfileFromDatabaseAsync(_currentUserId, cancellationToken);
-
+            
             if (result is not null)
-            {
-                var newProfile = result.ToUserProfile();
-                SetInternal(newProfile);
-            }
+                SetInternal(result.ToUserProfile());
         }
         catch (Exception ex)
         {
@@ -132,25 +86,14 @@ public async Task RefreshAsync(CancellationToken cancellationToken = default)
         }
     }
 
-    /// <summary>
-    /// Sets a new user profile directly (for local updates after database changes).
-    /// </summary>
     public void Set(UserProfile userProfile)
     {
         ArgumentNullException.ThrowIfNull(userProfile);
         _currentUserId = userProfile.UserId;
         SetInternal(userProfile);
-        // Clear cache in background - don't block the UI
-        _ = Task.Run(async () => 
-        {
-            var cacheKey = UserCacheKeys.GetCacheKey(userProfile.UserId, UserCacheType.Application);
-            await _fusionCache.RemoveAsync(cacheKey);
-        });
+        ClearCacheInBackground(userProfile.UserId);
     }
 
-    /// <summary>
-    /// Updates specific fields locally without database access.
-    /// </summary>
     public void UpdateLocal(
         string? profilePictureDataUrl = null,
         string? displayName = null,
@@ -159,9 +102,7 @@ public void UpdateLocal(
         string? languageCode = null)
     {
         if (_currentValue == UserProfile.Empty)
-        {
             return;
-        }
 
         var updatedProfile = _currentValue with
         {
@@ -173,56 +114,44 @@ public void UpdateLocal(
         };
 
         SetInternal(updatedProfile);
-        // Clear cache in background - don't block the UI
-        _ = Task.Run(async () => 
-        {
-            var cacheKey = UserCacheKeys.GetCacheKey(_currentValue.UserId, UserCacheType.Application);
-            await _fusionCache.RemoveAsync(cacheKey);
-        });
+        ClearCacheInBackground(_currentValue.UserId);
     }
 
-    /// <summary>
-    /// Clears the cache for the current user.
-    /// </summary>
     public void ClearCache()
     {
         if (!string.IsNullOrWhiteSpace(_currentUserId))
-        {
-            // Clear cache in background - don't block the UI
-            _ = Task.Run(async () => 
-            {
-                var cacheKey = UserCacheKeys.GetCacheKey(_currentUserId, UserCacheType.Application);
-                await _fusionCache.RemoveAsync(cacheKey);
-            });
-        }
+            ClearCacheInBackground(_currentUserId);
     }
 
     private void SetInternal(UserProfile newProfile)
     {
         var oldProfile = _currentValue;
         _currentValue = newProfile;
 
-        // Trigger event if profile actually changed
         if (!ReferenceEquals(oldProfile, newProfile))
-        {
             Changed?.Invoke(this, newProfile);
-        }
     }
 
-    private string GetApplicationUserCacheKey(string userId)
+    private void ClearCacheInBackground(string userId)
     {
-        ArgumentException.ThrowIfNullOrWhiteSpace(userId);
-        return UserCacheKeys.GetCacheKey(userId, UserCacheType.Application);
+        _ = Task.Run(async () =>
+        {
+            var cacheKey = UserCacheKeys.GetCacheKey(userId, UserCacheType.Application);
+            await _fusionCache.RemoveAsync(cacheKey);
+        });
+    }
+
+    private async Task ClearCacheAsync(string userId)
+    {
+        var cacheKey = UserCacheKeys.GetCacheKey(userId, UserCacheType.Application);
+        await _fusionCache.RemoveAsync(cacheKey);
     }
 
-    /// <summary>
-    /// Loads user profile data from database with caching.
-    /// </summary>
     private async Task<ApplicationUserDto?> LoadUserProfileFromDatabaseAsync(string userId, CancellationToken cancellationToken = default)
     {
-        var key = GetApplicationUserCacheKey(userId);
+        var cacheKey = UserCacheKeys.GetCacheKey(userId, UserCacheType.Application);
         return await _fusionCache.GetOrSetAsync(
-            key,
+            cacheKey,
             async _ =>
             {
                 using var scope = _scopeFactory.CreateScope();
@@ -234,12 +163,9 @@ private string GetApplicationUserCacheKey(string userId)
                             .ProjectTo<ApplicationUserDto>(_mapper.ConfigurationProvider)
                             .FirstOrDefaultAsync(cancellationToken);
             },
-            RefreshInterval);
+            TimeSpan.FromSeconds(CacheRefreshSeconds));
     }
 
-    /// <summary>
-    /// Updates the user's language code in the database and refreshes local state.
-    /// </summary>
     public async Task SetLanguageAsync(string languageCode, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(languageCode) || string.IsNullOrWhiteSpace(_currentUserId))
@@ -257,15 +183,12 @@ public async Task SetLanguageAsync(string languageCode, CancellationToken cancel
 
             user.LanguageCode = languageCode;
             var result = await userManager.UpdateAsync(user);
+            
             if (!result.Succeeded)
-            {
                 throw new InvalidOperationException($"Failed to update language. Errors: {string.Join(", ", result.Errors.Select(e => e.Description))}");
-            }
 
-            // Update local state and cache
             UpdateLocal(languageCode: languageCode);
-            var cacheKey = UserCacheKeys.GetCacheKey(_currentUserId, UserCacheType.Application);
-            await _fusionCache.RemoveAsync(cacheKey);
+            await ClearCacheAsync(_currentUserId);
         }
         catch (Exception ex)
         {

src/Infrastructure/Services/SecurityAnalysisService.cs

@@ -1,12 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using CleanArchitecture.Blazor.Application.Features.LoginAudits.Caching;
 using CleanArchitecture.Blazor.Domain.Enums;
 using CleanArchitecture.Blazor.Domain.Identity;
-using System.Collections.Concurrent;
-using System.Net;
-using System.Text.RegularExpressions;
 using ZiggyCreatures.Caching.Fusion;
 using Microsoft.Extensions.Localization;
 

src/Infrastructure/Services/TenantSwitchService.cs

@@ -1,5 +1,4 @@
 using CleanArchitecture.Blazor.Domain.Identity;
-using ZiggyCreatures.Caching.Fusion;
 using CleanArchitecture.Blazor.Application.Common.Constants;
 using CleanArchitecture.Blazor.Application.Common.Security;