Better profile caching.

2026-03-20 00:15:10 +01:00
parent d38317f0be
commit 4a20ea2577
10 changed files with 422 additions and 74 deletions
@@ -68,7 +68,8 @@ public class DatabaseService : IDatabaseService
            Connection.CreateTableAsync<CalendarAttachment>(),
            Connection.CreateTableAsync<Reminder>(),
            Connection.CreateTableAsync<MailInvitationCalendarMapping>(),
-            Connection.CreateTableAsync<WinoAccount>());
+            Connection.CreateTableAsync<WinoAccount>(),
+            Connection.CreateTableAsync<WinoAccountAddOnCache>());

        await EnsureSchemaUpgradesAsync().ConfigureAwait(false);
        await EnsureIndexesAsync().ConfigureAwait(false);
@@ -207,6 +208,7 @@ SET {nameof(KeyboardShortcut.Action)} =
        await Connection.ExecuteAsync("CREATE UNIQUE INDEX IF NOT EXISTS IX_MailAccountPreferences_AccountId ON MailAccountPreferences(AccountId)").ConfigureAwait(false);
        await Connection.ExecuteAsync("CREATE UNIQUE INDEX IF NOT EXISTS IX_CustomServerInformation_AccountId ON CustomServerInformation(AccountId)").ConfigureAwait(false);
        await Connection.ExecuteAsync("CREATE UNIQUE INDEX IF NOT EXISTS IX_WinoAccount_Email ON WinoAccount(Email)").ConfigureAwait(false);
+        await Connection.ExecuteAsync("CREATE UNIQUE INDEX IF NOT EXISTS IX_WinoAccountAddOnCache_AccountId ON WinoAccountAddOnCache(AccountId)").ConfigureAwait(false);

        // Calendar indexes
        await Connection.ExecuteAsync("CREATE INDEX IF NOT EXISTS IX_AccountCalendar_AccountId ON AccountCalendar(AccountId)").ConfigureAwait(false);
@@ -25,6 +25,7 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable
 {
    private readonly HttpClient _httpClient;
    private readonly IDatabaseService _databaseService;
+    private readonly SemaphoreSlim _tokenRefreshLock = new(1, 1);
    private readonly bool _ownsHttpClient;

    // private const string ApiUrl = "https://localhost:7204/";
@@ -134,11 +135,12 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable
    {
        try
        {
-            using var request = await CreateAuthorizedRequestAsync(HttpMethod.Get, "api/v1/users/me/settings").ConfigureAwait(false);
-            if (request == null)
-                return null;
+            using var response = await SendAuthorizedAsync(
+                () => CreateAuthorizedRequestAsync(HttpMethod.Get, "api/v1/users/me/settings"),
+                cancellationToken).ConfigureAwait(false);

-            using var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+            if (response == null)
+                return null;

            if (response.StatusCode == System.Net.HttpStatusCode.NoContent)
                return null;
@@ -158,13 +160,16 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable
    {
        try
        {
-            using var request = await CreateAuthorizedRequestAsync(HttpMethod.Put, "api/v1/users/me/settings").ConfigureAwait(false);
-            if (request == null)
+            using var response = await SendAuthorizedAsync(
+                () => CreateAuthorizedRequestAsync(
+                    HttpMethod.Put,
+                    "api/v1/users/me/settings",
+                    () => new StringContent(settingsJson, Encoding.UTF8, "application/json")),
+                cancellationToken).ConfigureAwait(false);
+
+            if (response == null)
                return false;

-            request.Content = new StringContent(settingsJson, Encoding.UTF8, "application/json");
-
-            using var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
            return response.IsSuccessStatusCode;
        }
        catch
@@ -325,11 +330,12 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable
    {
        try
        {
-            using var request = await CreateAuthorizedRequestAsync(method, endpoint).ConfigureAwait(false);
-            if (request == null)
-                return ApiEnvelope<TResponse>.Failure("MissingAccessToken");
+            using var response = await SendAuthorizedAsync(
+                () => CreateAuthorizedRequestAsync(method, endpoint),
+                cancellationToken).ConfigureAwait(false);

-            using var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+            if (response == null)
+                return ApiEnvelope<TResponse>.Failure("MissingAccessToken");

            var payload = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
            var envelope = string.IsNullOrWhiteSpace(payload)
@@ -344,7 +350,7 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable
        }
    }

-    private async Task<HttpRequestMessage?> CreateAuthorizedRequestAsync(HttpMethod method, string endpoint)
+    private async Task<HttpRequestMessage?> CreateAuthorizedRequestAsync(HttpMethod method, string endpoint, Func<HttpContent>? contentFactory = null)
    {
        var accessToken = await GetAccessTokenAsync().ConfigureAwait(false);
        if (string.IsNullOrWhiteSpace(accessToken))
@@ -352,15 +358,98 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable

        var request = new HttpRequestMessage(method, endpoint);
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
+        request.Content = contentFactory?.Invoke();
        return request;
    }

+    private async Task<HttpResponseMessage?> SendAuthorizedAsync(Func<Task<HttpRequestMessage?>> requestFactory, CancellationToken cancellationToken)
+    {
+        using var initialRequest = await requestFactory().ConfigureAwait(false);
+        if (initialRequest == null)
+        {
+            return null;
+        }
+
+        var response = await _httpClient.SendAsync(initialRequest, cancellationToken).ConfigureAwait(false);
+        if (response.StatusCode != System.Net.HttpStatusCode.Unauthorized)
+        {
+            return response;
+        }
+
+        if (!await TryRefreshAccessTokenAsync(cancellationToken).ConfigureAwait(false))
+        {
+            return response;
+        }
+
+        response.Dispose();
+
+        using var retryRequest = await requestFactory().ConfigureAwait(false);
+        if (retryRequest == null)
+        {
+            return null;
+        }
+
+        return await _httpClient.SendAsync(retryRequest, cancellationToken).ConfigureAwait(false);
+    }
+
    private async Task<string?> GetAccessTokenAsync()
    {
        var account = await _databaseService.Connection.Table<WinoAccount>().FirstOrDefaultAsync().ConfigureAwait(false);
        return string.IsNullOrWhiteSpace(account?.AccessToken) ? null : account.AccessToken;
    }

+    private async Task<bool> TryRefreshAccessTokenAsync(CancellationToken cancellationToken)
+    {
+        await _tokenRefreshLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+        try
+        {
+            var account = await _databaseService.Connection.Table<WinoAccount>().FirstOrDefaultAsync().ConfigureAwait(false);
+            if (account == null || string.IsNullOrWhiteSpace(account.RefreshToken))
+            {
+                return false;
+            }
+
+            if (!string.IsNullOrWhiteSpace(account.AccessToken) && account.AccessTokenExpiresAtUtc > DateTime.UtcNow.AddMinutes(1))
+            {
+                return true;
+            }
+
+            var refreshResult = await RefreshAsync(account.RefreshToken, cancellationToken).ConfigureAwait(false);
+            if (!refreshResult.IsSuccess || refreshResult.Result == null)
+            {
+                return false;
+            }
+
+            var refreshedAccount = MapAccount(refreshResult.Result, account.LastAuthenticatedUtc);
+
+            await _databaseService.Connection.DeleteAllAsync<WinoAccount>().ConfigureAwait(false);
+            await _databaseService.Connection.InsertOrReplaceAsync(refreshedAccount, typeof(WinoAccount)).ConfigureAwait(false);
+
+            return true;
+        }
+        finally
+        {
+            _tokenRefreshLock.Release();
+        }
+    }
+
+    private static WinoAccount MapAccount(AuthResultDto result, DateTime lastAuthenticatedUtc)
+        => new()
+        {
+            Id = result.User.UserId,
+            Email = result.User.Email,
+            AccountStatus = result.User.AccountStatus,
+            HasPassword = result.User.HasPassword,
+            HasGoogleLogin = result.User.HasGoogleLogin,
+            HasFacebookLogin = result.User.HasFacebookLogin,
+            AccessToken = result.AccessToken,
+            AccessTokenExpiresAtUtc = result.AccessTokenExpiresAtUtc.UtcDateTime,
+            RefreshToken = result.RefreshToken,
+            RefreshTokenExpiresAtUtc = result.RefreshTokenExpiresAtUtc.UtcDateTime,
+            LastAuthenticatedUtc = lastAuthenticatedUtc == default ? DateTime.UtcNow : lastAuthenticatedUtc
+        };
+
    private static bool ValidateCertificate(HttpRequestMessage requestMessage, X509Certificate2? certificate, X509Chain? chain, System.Net.Security.SslPolicyErrors sslPolicyErrors)
    {
        if (requestMessage.RequestUri?.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase) == true)
@@ -377,6 +466,8 @@ public sealed class WinoAccountApiClient : IWinoAccountApiClient, IDisposable
        {
            _httpClient.Dispose();
        }
+
+        _tokenRefreshLock.Dispose();
    }
 }

@@ -22,6 +22,7 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
    private readonly IWinoAccountApiClient _apiClient;
    private readonly IStoreManagementService _storeManagementService;
    private readonly SemaphoreSlim _billingCallbackLock = new(1, 1);
+    private readonly SemaphoreSlim _tokenRefreshLock = new(1, 1);
    private readonly ILogger _logger = Log.ForContext<WinoAccountProfileService>();

    public WinoAccountProfileService(IDatabaseService databaseService,
@@ -67,29 +68,43 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun

    public async Task<WinoAccountOperationResult> RefreshAsync(CancellationToken cancellationToken = default)
    {
-        var account = await GetActiveAccountAsync().ConfigureAwait(false);
-        if (account == null || string.IsNullOrWhiteSpace(account.RefreshToken))
-        {
-            _logger.Warning("Wino account token refresh skipped because there is no active account or refresh token.");
-            return WinoAccountOperationResult.Failure(ApiErrorCodes.RefreshTokenInvalid);
-        }
+        await _tokenRefreshLock.WaitAsync(cancellationToken).ConfigureAwait(false);

-        _logger.Information("Refreshing Wino account token for {Email}", account.Email);
-        var response = await _apiClient.RefreshAsync(account.RefreshToken, cancellationToken).ConfigureAwait(false);
-        var result = await PersistResponseAsync(response).ConfigureAwait(false);
-
-        if (!result.IsSuccess)
+        try
        {
-            _logger.Warning("Wino account token refresh failed for {Email}. Error code: {ErrorCode}", account.Email, result.ErrorCode);
+            var account = await GetActiveAccountAsync().ConfigureAwait(false);
+            if (account == null || string.IsNullOrWhiteSpace(account.RefreshToken))
+            {
+                _logger.Warning("Wino account token refresh skipped because there is no active account or refresh token.");
+                return WinoAccountOperationResult.Failure(ApiErrorCodes.RefreshTokenInvalid);
+            }
+
+            if (!string.IsNullOrWhiteSpace(account.AccessToken) && account.AccessTokenExpiresAtUtc > DateTime.UtcNow.AddMinutes(1))
+            {
+                return WinoAccountOperationResult.Success(account);
+            }
+
+            _logger.Information("Refreshing Wino account token for {Email}", account.Email);
+            var response = await _apiClient.RefreshAsync(account.RefreshToken, cancellationToken).ConfigureAwait(false);
+            var result = await PersistResponseAsync(response).ConfigureAwait(false);
+
+            if (!result.IsSuccess)
+            {
+                _logger.Warning("Wino account token refresh failed for {Email}. Error code: {ErrorCode}", account.Email, result.ErrorCode);
+                return result;
+            }
+
+            if (result.Account != null && !AreEquivalentProfiles(account, result.Account))
+            {
+                PublishProfileUpdated(result.Account);
+            }
+
            return result;
        }
-
-        if (result.Account != null && !AreEquivalentProfiles(account, result.Account))
+        finally
        {
-            PublishProfileUpdated(result.Account);
+            _tokenRefreshLock.Release();
        }
-
-        return result;
    }

    public async Task<WinoAccountOperationResult> RefreshProfileAsync(CancellationToken cancellationToken = default)
@@ -108,6 +123,15 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        }

        var refreshedAccount = MergeAccountProfile(account, response.Result);
+        var hasUnlimitedAccounts = TryGetBooleanProperty(response.Result, "HasUnlimitedAccounts", out var cachedHasUnlimitedAccounts)
+            ? cachedHasUnlimitedAccounts
+            : (bool?)null;
+
+        if (hasUnlimitedAccounts.HasValue)
+        {
+            await PersistAddOnCacheAsync(refreshedAccount.Id, null, hasUnlimitedAccounts.Value).ConfigureAwait(false);
+        }
+
        if (AreEquivalentProfiles(account, refreshedAccount))
        {
            return WinoAccountOperationResult.Success(account);
@@ -125,6 +149,18 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        return account;
    }

+    public async Task<WinoAccountAddOnSnapshot?> GetCachedAddOnSnapshotAsync()
+    {
+        var account = await GetActiveAccountAsync().ConfigureAwait(false);
+        if (account == null)
+        {
+            return null;
+        }
+
+        var cache = await GetAddOnCacheAsync(account.Id).ConfigureAwait(false);
+        return cache == null ? null : Map(cache);
+    }
+
    public async Task<WinoAccount?> GetAuthenticatedAccountAsync(CancellationToken cancellationToken = default)
    {
        var account = await GetActiveAccountAsync().ConfigureAwait(false);
@@ -179,6 +215,17 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        if (!response.IsSuccess)
        {
            _logger.Warning("Failed to load Wino account profile for {Email}. Error code: {ErrorCode}", account.Email, response.ErrorCode);
+            return response;
+        }
+
+        if (response.Result != null)
+        {
+            var refreshedAccount = MergeAccountProfile(account, response.Result);
+            var hasUnlimitedAccounts = TryGetBooleanProperty(response.Result, "HasUnlimitedAccounts", out var cachedHasUnlimitedAccounts)
+                ? cachedHasUnlimitedAccounts
+                : (bool?)null;
+
+            await PersistProfileDataAsync(account, refreshedAccount, hasUnlimitedAccounts).ConfigureAwait(false);
        }

        return response;
@@ -196,6 +243,12 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        if (!response.IsSuccess)
        {
            _logger.Warning("Failed to load AI status for Wino account {Email}. Error code: {ErrorCode}", account.Email, response.ErrorCode);
+            return response;
+        }
+
+        if (response.Result != null)
+        {
+            await PersistAddOnCacheAsync(account.Id, response.Result).ConfigureAwait(false);
        }

        return response;
@@ -303,6 +356,7 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        }

        await Connection.DeleteAllAsync<WinoAccount>().ConfigureAwait(false);
+        await Connection.DeleteAllAsync<WinoAccountAddOnCache>().ConfigureAwait(false);

        if (account != null)
        {
@@ -332,6 +386,20 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        await Connection.InsertOrReplaceAsync(account, typeof(WinoAccount)).ConfigureAwait(false);
    }

+    private async Task PersistProfileDataAsync(WinoAccount originalAccount, WinoAccount refreshedAccount, bool? hasUnlimitedAccounts)
+    {
+        if (!AreEquivalentProfiles(originalAccount, refreshedAccount))
+        {
+            await PersistAccountAsync(refreshedAccount).ConfigureAwait(false);
+            PublishProfileUpdated(refreshedAccount);
+        }
+
+        if (hasUnlimitedAccounts.HasValue)
+        {
+            await PersistAddOnCacheAsync(refreshedAccount.Id, null, hasUnlimitedAccounts.Value).ConfigureAwait(false);
+        }
+    }
+
    private void PublishProfileUpdated(WinoAccount account)
        => ReportUIChange(new WinoAccountProfileUpdatedMessage(account));

@@ -343,6 +411,12 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun

    private async Task<bool> HasUnlimitedAccountsAsync(CancellationToken cancellationToken)
    {
+        var cachedSnapshot = await GetCachedAddOnSnapshotAsync().ConfigureAwait(false);
+        if (cachedSnapshot?.HasUnlimitedAccounts == true)
+        {
+            return true;
+        }
+
        if (await HasRemoteUnlimitedAccountsAsync(cancellationToken).ConfigureAwait(false))
        {
            return true;
@@ -356,12 +430,54 @@ public sealed class WinoAccountProfileService : BaseDatabaseService, IWinoAccoun
        var response = await GetCurrentUserAsync(cancellationToken).ConfigureAwait(false);
        if (!response.IsSuccess || response.Result == null)
        {
-            return false;
+            return (await GetCachedAddOnSnapshotAsync().ConfigureAwait(false))?.HasUnlimitedAccounts == true;
        }

        return TryGetBooleanProperty(response.Result, "HasUnlimitedAccounts", out var hasUnlimitedAccounts) && hasUnlimitedAccounts;
    }

+    private async Task<WinoAccountAddOnCache?> GetAddOnCacheAsync(Guid accountId)
+        => await Connection.Table<WinoAccountAddOnCache>()
+                           .Where(cache => cache.AccountId == accountId)
+                           .FirstOrDefaultAsync()
+                           .ConfigureAwait(false);
+
+    private async Task PersistAddOnCacheAsync(Guid accountId, AiStatusResultDto? aiStatus = null, bool? hasUnlimitedAccounts = null)
+    {
+        var cache = await GetAddOnCacheAsync(accountId).ConfigureAwait(false) ?? new WinoAccountAddOnCache
+        {
+            AccountId = accountId
+        };
+
+        if (aiStatus != null)
+        {
+            cache.HasAiPack = aiStatus.HasAiPack;
+            cache.AiUsageCount = aiStatus.HasAiPack ? aiStatus.Used : null;
+            cache.AiUsageLimit = aiStatus.HasAiPack ? aiStatus.MonthlyLimit : null;
+            cache.AiBillingPeriodStartUtc = aiStatus.CurrentPeriodStartUtc?.UtcDateTime;
+            cache.AiBillingPeriodEndUtc = aiStatus.CurrentPeriodEndUtc?.UtcDateTime;
+        }
+
+        if (hasUnlimitedAccounts.HasValue)
+        {
+            cache.HasUnlimitedAccounts = hasUnlimitedAccounts.Value;
+        }
+
+        cache.LastUpdatedUtc = DateTime.UtcNow;
+
+        await Connection.InsertOrReplaceAsync(cache, typeof(WinoAccountAddOnCache)).ConfigureAwait(false);
+    }
+
+    private static WinoAccountAddOnSnapshot Map(WinoAccountAddOnCache cache)
+        => new(
+            cache.HasAiPack,
+            cache.AiUsageCount,
+            cache.AiUsageLimit,
+            cache.AiBillingPeriodStartUtc is DateTime periodStartUtc ? new DateTimeOffset(DateTime.SpecifyKind(periodStartUtc, DateTimeKind.Utc)) : null,
+            cache.AiBillingPeriodEndUtc is DateTime periodEndUtc ? new DateTimeOffset(DateTime.SpecifyKind(periodEndUtc, DateTimeKind.Utc)) : null,
+            cache.HasUnlimitedAccounts,
+            new DateTimeOffset(DateTime.SpecifyKind(cache.LastUpdatedUtc, DateTimeKind.Utc)));
+
    private static bool AreEquivalentProfiles(WinoAccount left, WinoAccount right)
        => left.Id == right.Id &&
           string.Equals(left.Email, right.Email, StringComparison.Ordinal) &&
@@ -10,12 +10,6 @@ namespace Wino.Services;

 public sealed class WinoAddOnService : IWinoAddOnService
 {
-    private static readonly WinoAddOnProductType[] AvailableAddOns =
-    [
-        WinoAddOnProductType.AI_PACK,
-        WinoAddOnProductType.UNLIMITED_ACCOUNTS
-    ];
-
    private readonly IWinoAccountProfileService _profileService;

    public WinoAddOnService(IWinoAccountProfileService profileService)
@@ -23,8 +17,15 @@ public sealed class WinoAddOnService : IWinoAddOnService
        _profileService = profileService;
    }

-    public async Task<IReadOnlyList<WinoAddOnInfo>> GetAvailableAddOnsAsync(CancellationToken cancellationToken = default)
+    public async Task<IReadOnlyList<WinoAddOnInfo>> GetAvailableAddOnsAsync(bool useCachedDataOnly = false, CancellationToken cancellationToken = default)
    {
+        var cachedSnapshot = await _profileService.GetCachedAddOnSnapshotAsync().ConfigureAwait(false);
+
+        if (useCachedDataOnly)
+        {
+            return BuildAddOnInfos(cachedSnapshot);
+        }
+
        var aiStatusTask = _profileService.GetAiStatusAsync(cancellationToken);
        var hasUnlimitedAccountsTask = _profileService.HasAddOnAsync(WinoAddOnProductType.UNLIMITED_ACCOUNTS, cancellationToken);

@@ -32,6 +33,15 @@ public sealed class WinoAddOnService : IWinoAddOnService

        var aiStatusResponse = await aiStatusTask.ConfigureAwait(false);
        var aiStatus = aiStatusResponse.IsSuccess ? aiStatusResponse.Result : null;
+        var hasUnlimitedAccounts = await hasUnlimitedAccountsTask.ConfigureAwait(false);
+
+        if (aiStatus == null && cachedSnapshot != null)
+        {
+            return BuildAddOnInfos(cachedSnapshot with
+            {
+                HasUnlimitedAccounts = hasUnlimitedAccounts || cachedSnapshot.HasUnlimitedAccounts
+            });
+        }

        return
        [
@@ -46,7 +56,31 @@ public sealed class WinoAddOnService : IWinoAddOnService
                aiStatus?.CurrentPeriodEndUtc),
            new WinoAddOnInfo(
                WinoAddOnProductType.UNLIMITED_ACCOUNTS,
-                await hasUnlimitedAccountsTask.ConfigureAwait(false))
+                hasUnlimitedAccounts || cachedSnapshot?.HasUnlimitedAccounts == true)
+        ];
+    }
+
+    private static IReadOnlyList<WinoAddOnInfo> BuildAddOnInfos(WinoAccountAddOnSnapshot? snapshot)
+    {
+        if (snapshot == null)
+        {
+            return [];
+        }
+
+        return
+        [
+            new WinoAddOnInfo(
+                WinoAddOnProductType.AI_PACK,
+                snapshot.HasAiPack,
+                snapshot.UsageCount,
+                snapshot.UsageLimit,
+                snapshot.HasAiPack && snapshot.UsageLimit is int limit && limit > 0 && snapshot.UsageCount is int used
+                    ? (double)used / limit * 100
+                    : 0,
+                snapshot.BillingPeriodEndUtc),
+            new WinoAddOnInfo(
+                WinoAddOnProductType.UNLIMITED_ACCOUNTS,
+                snapshot.HasUnlimitedAccounts)
        ];
    }
 }