Add IUserTimeZoneService to make it easier to mock UserTimeZoneService

src/OrchardCore.Modules/OrchardCore.Users/Extensions/UserTimeZoneServiceExtensions.cs

@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.DependencyInjection;
+using OrchardCore.Modules;
+using OrchardCore.Users.Models;
+using OrchardCore.Users.TimeZone.Services;
+
+namespace OrchardCore.Users;
+
+/// <summary>
+/// Provides an extension for <see cref="IUserTimeZoneService"/>.
+/// </summary>
+public static class UserTimeZoneServiceExtensions
+{
+    /// <summary>
+    /// Gets the time zone for currently logged-in user.
+    /// </summary>
+    /// <param name="userTimeZoneService">The <see cref="IUserTimeZoneService"/>.</param>
+    public static async ValueTask<ITimeZone> GetTimeZoneAsync(this IUserTimeZoneService userTimeZoneService)
+    {
+        ArgumentNullException.ThrowIfNull(nameof(userTimeZoneService));
+
+        var currentUser = await GetCurrentUserAsync(userTimeZoneService.HttpContext);
+
+        return await userTimeZoneService.GetTimeZoneAsync(currentUser);
+    }
+
+    /// <summary>
+    /// Updates the time zone for currently logged-in user.
+    /// </summary>
+    /// <param name="userTimeZoneService">The <see cref="IUserTimeZoneService"/>.</param>
+    public static async ValueTask UpdateTimeZoneAsync(this IUserTimeZoneService userTimeZoneService)
+    {
+        ArgumentNullException.ThrowIfNull(nameof(userTimeZoneService));
+
+        var currentUser = await GetCurrentUserAsync(userTimeZoneService.HttpContext);
+
+        await userTimeZoneService.UpdateTimeZoneAsync(currentUser);
+    }
+
+    private static async Task<IUser> GetCurrentUserAsync(HttpContext httpContext)
+    {
+        var userName = httpContext.User?.Identity?.Name;
+        var userManager = httpContext.RequestServices.GetRequiredService<UserManager<IUser>>();
+
+        return await userManager.FindByNameAsync(userName) as User;
+    }
+}

src/OrchardCore.Modules/OrchardCore.Users/TimeZone/Drivers/UserTimeZoneDisplayDriver.cs

@@ -10,9 +10,9 @@ namespace OrchardCore.Users.TimeZone.Drivers;
 
 public sealed class UserTimeZoneDisplayDriver : SectionDisplayDriver<User, UserTimeZone>
 {
-    private readonly UserTimeZoneService _userTimeZoneService;
+    private readonly IUserTimeZoneService _userTimeZoneService;
 
-    public UserTimeZoneDisplayDriver(UserTimeZoneService userTimeZoneService)
+    public UserTimeZoneDisplayDriver(IUserTimeZoneService userTimeZoneService)
     {
         _userTimeZoneService = userTimeZoneService;
     }
@@ -33,7 +33,7 @@ public override async Task<IDisplayResult> UpdateAsync(User user, UserTimeZone u
         userTimeZone.TimeZoneId = model.TimeZoneId;
 
         // Remove the cache entry, don't update it, as the form might still fail validation for other reasons.
-        await _userTimeZoneService.UpdateUserTimeZoneAsync(user);
+        await _userTimeZoneService.UpdateTimeZoneAsync(user);
 
         return await EditAsync(user, userTimeZone, context);
     }

src/OrchardCore.Modules/OrchardCore.Users/TimeZone/Services/IUserTimeZoneService.cs

@@ -0,0 +1,27 @@
+using Microsoft.AspNetCore.Http;
+using OrchardCore.Modules;
+
+namespace OrchardCore.Users.TimeZone.Services;
+
+/// <summary>
+/// Contract for user time zone service.
+/// </summary>
+public interface IUserTimeZoneService
+{
+    /// <summary>
+    /// Gets the current <see cref="HttpContext"/>.
+    /// </summary>
+    public HttpContext HttpContext { get; }
+
+    /// <summary>
+    /// Gets the time zone for the specified user.
+    /// </summary>
+    /// <param name="user">The <see cref="IUser"/>.</param>
+    public ValueTask<ITimeZone> GetTimeZoneAsync(IUser user);
+
+    /// <summary>
+    /// Updates the time zone for the specified user.
+    /// </summary>
+    /// <param name="user">The <see cref="IUser"/>.</param>
+    public ValueTask UpdateTimeZoneAsync(IUser user);
+}

src/OrchardCore.Modules/OrchardCore.Users/TimeZone/Services/UserTimeZoneSelector.cs

@@ -7,9 +7,9 @@ namespace OrchardCore.Users.TimeZone.Services;
 /// </summary>
 public class UserTimeZoneSelector : ITimeZoneSelector
 {
-    private readonly UserTimeZoneService _userTimeZoneService;
+    private readonly IUserTimeZoneService _userTimeZoneService;
 
-    public UserTimeZoneSelector(UserTimeZoneService userTimeZoneService)
+    public UserTimeZoneSelector(IUserTimeZoneService userTimeZoneService)
     {
         _userTimeZoneService = userTimeZoneService;
     }
@@ -21,7 +21,7 @@ public Task<TimeZoneSelectorResult> GetTimeZoneAsync()
             {
                 Priority = 100,
                 TimeZoneId = async () =>
-                    (await _userTimeZoneService.GetUserTimeZoneAsync())?.TimeZoneId
+                    (await _userTimeZoneService.GetTimeZoneAsync())?.TimeZoneId
             }
         );
     }

src/OrchardCore.Modules/OrchardCore.Users/TimeZone/Services/UserTimeZoneService.cs

@@ -9,30 +9,35 @@
 
 namespace OrchardCore.Users.TimeZone.Services;
 
-public class UserTimeZoneService
+/// <summary>
+/// Represents a time zone service for currently logged-in user.
+/// </summary>
+public class UserTimeZoneService : IUserTimeZoneService
 {
-    private const string EmptyTimeZone = "empty";
     private const string CacheKey = "UserTimeZone/";
+    private const string EmptyTimeZone = "empty";
+
     private static readonly DistributedCacheEntryOptions _slidingExpiration = new() { SlidingExpiration = TimeSpan.FromHours(1) };
 
     private readonly IClock _clock;
     private readonly IDistributedCache _distributedCache;
-    private readonly IHttpContextAccessor _httpContextAccessor;
 
     public UserTimeZoneService(
         IClock clock,
         IDistributedCache distributedCache,
-        IHttpContextAccessor httpContextAccessor
-    )
+        IHttpContextAccessor httpContextAccessor)
     {
         _clock = clock;
         _distributedCache = distributedCache;
-        _httpContextAccessor = httpContextAccessor;
+        HttpContext = httpContextAccessor.HttpContext;
     }
 
-    public async ValueTask<ITimeZone> GetUserTimeZoneAsync()
+    public HttpContext HttpContext { get; }
+
+    /// <inheritdoc/>
+    public async ValueTask<ITimeZone> GetTimeZoneAsync(IUser user)
     {
-        var currentTimeZoneId = await GetCurrentUserTimeZoneIdAsync();
+        var currentTimeZoneId = await GetTimeZoneIdAsync();
 
         if (string.IsNullOrEmpty(currentTimeZoneId))
         {
@@ -42,7 +47,8 @@ public async ValueTask<ITimeZone> GetUserTimeZoneAsync()
         return _clock.GetTimeZone(currentTimeZoneId);
     }
 
-    public async ValueTask UpdateUserTimeZoneAsync(IUser user)
+    /// <inheritdoc/>
+    public async ValueTask UpdateTimeZoneAsync(IUser user)
     {
         var userName = user?.UserName;
 
@@ -54,23 +60,25 @@ public async ValueTask UpdateUserTimeZoneAsync(IUser user)
         return;
     }
 
-    public async ValueTask<string> GetCurrentUserTimeZoneIdAsync()
+    /// <inheritdoc/>
+    private async ValueTask<string> GetTimeZoneIdAsync()
     {
-        var userName = _httpContextAccessor.HttpContext?.User?.Identity?.Name;
+        var userName = HttpContext.User?.Identity?.Name;
 
         if (string.IsNullOrEmpty(userName))
         {
             return null;
         }
 
         var key = GetCacheKey(userName);
+
         var timeZoneId = await _distributedCache.GetStringAsync(key);
 
         // The timezone is not cached yet, resolve it and store the value
         if (string.IsNullOrEmpty(timeZoneId))
         {
             // Delay-loading UserManager since it is registered as scoped
-            var userManager = _httpContextAccessor.HttpContext.RequestServices.GetRequiredService<UserManager<IUser>>();
+            var userManager = HttpContext.RequestServices.GetRequiredService<UserManager<IUser>>();
             var user = await userManager.FindByNameAsync(userName) as User;
             timeZoneId = user.As<UserTimeZone>()?.TimeZoneId;
 
@@ -81,11 +89,7 @@ public async ValueTask<string> GetCurrentUserTimeZoneIdAsync()
                 timeZoneId = EmptyTimeZone;
             }
 
-            await _distributedCache.SetStringAsync(
-                key,
-                timeZoneId,
-                _slidingExpiration
-            );
+            await _distributedCache.SetStringAsync(key, timeZoneId, _slidingExpiration);
         }
 
         // Do we know this user doesn't have a configured value?

src/OrchardCore.Modules/OrchardCore.Users/TimeZone/Startup.cs

@@ -13,7 +13,7 @@ public sealed class Startup : StartupBase
     public override void ConfigureServices(IServiceCollection services)
     {
         services.AddScoped<ITimeZoneSelector, UserTimeZoneSelector>();
-        services.AddSingleton<UserTimeZoneService>();
+        services.AddSingleton<IUserTimeZoneService, UserTimeZoneService>();
         services.AddScoped<IDisplayDriver<User>, UserTimeZoneDisplayDriver>();
     }
 }