Burak Kaan Köse
650 lines
24 KiB
C#
650 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using CommunityToolkit.Mvvm.ComponentModel;
|
|
using CommunityToolkit.Mvvm.Input;
|
|
using CommunityToolkit.Mvvm.Messaging;
|
|
using Wino.Core.Domain;
|
|
using Wino.Core.Domain.Entities.Shared;
|
|
using Wino.Core.Domain.Enums;
|
|
using Wino.Core.Domain.Interfaces;
|
|
using Wino.Core.Domain.Models.Navigation;
|
|
using Wino.Core.Domain.Models.Accounts;
|
|
using Wino.Core.Domain.Models.Personalization;
|
|
using Wino.Core.Domain.Models.Settings;
|
|
using Wino.Core.Domain.Models.Translations;
|
|
using Wino.Core.Extensions;
|
|
using Wino.Core.ViewModels.Data;
|
|
using Wino.Mail.Api.Contracts.Ai;
|
|
using Wino.Mail.ViewModels.Data;
|
|
using Wino.Messaging.Client.Navigation;
|
|
using Wino.Messaging.UI;
|
|
|
|
namespace Wino.Core.ViewModels;
|
|
|
|
public partial class SettingOptionsPageViewModel : CoreBaseViewModel,
|
|
IRecipient<WinoAccountProfileUpdatedMessage>,
|
|
IRecipient<WinoAccountProfileDeletedMessage>,
|
|
IRecipient<WinoAccountAddOnPurchasedMessage>
|
|
{
|
|
private const string BuyAiPackUrl = "https://example.com/wino-ai-pack";
|
|
|
|
private readonly INativeAppService _nativeAppService;
|
|
private readonly IAccountService _accountService;
|
|
private readonly IMimeStorageService _mimeStorageService;
|
|
private readonly IStoreRatingService _storeRatingService;
|
|
private readonly ITranslationService _translationService;
|
|
private readonly INewThemeService _newThemeService;
|
|
private readonly IPreferencesService _preferencesService;
|
|
private readonly IProviderService _providerService;
|
|
private readonly IWinoAccountProfileService _profileService;
|
|
private readonly IMailDialogService _dialogService;
|
|
private bool _isInitializingSettings;
|
|
private bool _isAppearanceSelectionPaused;
|
|
|
|
public string GitHubUrl => AppUrls.GitHub;
|
|
public string PaypalUrl => AppUrls.Paypal;
|
|
public string WebsiteUrl => AppUrls.Website;
|
|
public string PrivacyPolicyUrl => AppUrls.PrivacyPolicy;
|
|
|
|
public ObservableCollection<SettingsNavigationItemInfo> SearchSuggestions { get; } = [];
|
|
public ObservableCollection<IAccountProviderDetailViewModel> Accounts { get; } = [];
|
|
public ObservableCollection<AppColorViewModel> Colors { get; } = [];
|
|
|
|
public List<ElementThemeContainer> ElementThemes { get; } =
|
|
[
|
|
new(ApplicationElementTheme.Light, Translator.ElementTheme_Light),
|
|
new(ApplicationElementTheme.Dark, Translator.ElementTheme_Dark),
|
|
new(ApplicationElementTheme.Default, Translator.ElementTheme_Default),
|
|
];
|
|
|
|
public bool HasAccounts => Accounts.Count > 0;
|
|
|
|
[ObservableProperty]
|
|
public partial string VersionText { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial string AccountSummaryText { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial int AccountCount { get; set; }
|
|
|
|
[ObservableProperty]
|
|
public partial string StorageSummaryText { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial string SearchQuery { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial List<AppLanguageModel> AvailableLanguages { get; set; } = [];
|
|
|
|
[ObservableProperty]
|
|
public partial AppLanguageModel SelectedLanguage { get; set; }
|
|
|
|
[ObservableProperty]
|
|
public partial ElementThemeContainer SelectedElementTheme { get; set; }
|
|
|
|
[ObservableProperty]
|
|
public partial AppColorViewModel SelectedAppColor { get; set; }
|
|
|
|
[ObservableProperty]
|
|
public partial bool UseAccentColor { get; set; }
|
|
|
|
// Wino Account hero card properties
|
|
|
|
[ObservableProperty]
|
|
public partial bool IsWinoAccountBusy { get; set; }
|
|
|
|
[ObservableProperty]
|
|
[NotifyPropertyChangedFor(nameof(IsWinoAccountSignedOut))]
|
|
[NotifyPropertyChangedFor(nameof(CanShowBuyAiPack))]
|
|
public partial bool IsWinoAccountSignedIn { get; set; }
|
|
|
|
[ObservableProperty]
|
|
public partial string WinoAccountEmail { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial string WinoAccountStatusText { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
[NotifyPropertyChangedFor(nameof(CanShowBuyAiPack))]
|
|
public partial bool HasAiPack { get; set; }
|
|
|
|
[ObservableProperty]
|
|
public partial string AiPackStateText { get; set; } = Translator.WinoAccount_Management_AiPackInactive;
|
|
|
|
[ObservableProperty]
|
|
public partial string AiUsageSummary { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial string AiBillingPeriodSummary { get; set; } = string.Empty;
|
|
|
|
[ObservableProperty]
|
|
public partial double AiUsagePercent { get; set; }
|
|
|
|
public bool IsWinoAccountSignedOut => !IsWinoAccountSignedIn;
|
|
public bool CanShowAiUsage => HasAiPack;
|
|
public bool CanShowBuyAiPack => IsWinoAccountSignedIn && !HasAiPack;
|
|
|
|
public SettingOptionsPageViewModel(INativeAppService nativeAppService,
|
|
IAccountService accountService,
|
|
IMimeStorageService mimeStorageService,
|
|
IStoreRatingService storeRatingService,
|
|
ITranslationService translationService,
|
|
INewThemeService newThemeService,
|
|
IPreferencesService preferencesService,
|
|
IProviderService providerService,
|
|
IWinoAccountProfileService profileService,
|
|
IMailDialogService dialogService)
|
|
{
|
|
_nativeAppService = nativeAppService;
|
|
_accountService = accountService;
|
|
_mimeStorageService = mimeStorageService;
|
|
_storeRatingService = storeRatingService;
|
|
_translationService = translationService;
|
|
_newThemeService = newThemeService;
|
|
_preferencesService = preferencesService;
|
|
_providerService = providerService;
|
|
_profileService = profileService;
|
|
_dialogService = dialogService;
|
|
}
|
|
|
|
public override void OnNavigatedTo(NavigationMode mode, object parameters)
|
|
{
|
|
base.OnNavigatedTo(mode, parameters);
|
|
|
|
VersionText = string.Format("{0}{1}", Translator.SettingsAboutVersion, _nativeAppService.GetFullAppVersion());
|
|
SearchQuery = string.Empty;
|
|
SearchSuggestions.Clear();
|
|
StorageSummaryText = Translator.SettingsHome_StorageLoading;
|
|
InitializeQuickSettings();
|
|
|
|
_ = LoadDashboardAsync();
|
|
_ = LoadWinoAccountAsync();
|
|
}
|
|
|
|
public void UpdateSearchSuggestions(string query)
|
|
{
|
|
SearchQuery = query;
|
|
|
|
SearchSuggestions.Clear();
|
|
|
|
foreach (var result in SettingsNavigationInfoProvider.Search(query, AccountSummaryText).Take(6))
|
|
{
|
|
SearchSuggestions.Add(result);
|
|
}
|
|
}
|
|
|
|
public SettingsNavigationItemInfo GetBestSearchSuggestion(string query)
|
|
=> SettingsNavigationInfoProvider.Search(query, AccountSummaryText).FirstOrDefault();
|
|
|
|
public void NavigateToSetting(SettingsNavigationItemInfo item)
|
|
{
|
|
if (item?.PageType is WinoPage pageType)
|
|
{
|
|
NavigateSubDetail(pageType);
|
|
}
|
|
}
|
|
|
|
public void NavigateToAccount(IAccountProviderDetailViewModel account)
|
|
{
|
|
if (account == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Messenger.Send(new BreadcrumbNavigationRequested(Translator.SettingsManageAccountSettings_Title, WinoPage.ManageAccountsPage));
|
|
|
|
switch (account)
|
|
{
|
|
case AccountProviderDetailViewModel accountDetails:
|
|
Messenger.Send(new BreadcrumbNavigationRequested(accountDetails.Account.Name, WinoPage.AccountDetailsPage, accountDetails.Account.Id));
|
|
break;
|
|
case MergedAccountProviderDetailViewModel mergedAccount:
|
|
Messenger.Send(new BreadcrumbNavigationRequested(mergedAccount.MergedInbox.Name, WinoPage.MergedAccountDetailsPage, mergedAccount));
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void NavigateToAddAccount()
|
|
{
|
|
Messenger.Send(new BreadcrumbNavigationRequested(Translator.SettingsManageAccountSettings_Title, WinoPage.ManageAccountsPage));
|
|
Messenger.Send(new BreadcrumbNavigationRequested(Translator.WelcomeWizard_Step2Title, WinoPage.ProviderSelectionPage));
|
|
}
|
|
|
|
private async Task LoadDashboardAsync()
|
|
{
|
|
var accounts = (await _accountService.GetAccountsAsync().ConfigureAwait(false) ?? []).ToList();
|
|
var count = accounts.Count;
|
|
Dictionary<Guid, long> storageSizeMap = count == 0
|
|
? []
|
|
: await _mimeStorageService.GetAccountsMimeStorageSizesAsync(accounts.Select(account => account.Id)).ConfigureAwait(false);
|
|
var totalStorageBytes = storageSizeMap.Values.Sum();
|
|
var groupedAccountItems = CreateAccountItems(accounts);
|
|
|
|
await ExecuteUIThread(() =>
|
|
{
|
|
AccountCount = count;
|
|
AccountSummaryText = string.Format(Translator.SettingsOptions_AccountsSummary, count);
|
|
Accounts.Clear();
|
|
|
|
foreach (var account in groupedAccountItems)
|
|
{
|
|
Accounts.Add(account);
|
|
}
|
|
|
|
OnPropertyChanged(nameof(HasAccounts));
|
|
StorageSummaryText = totalStorageBytes == 0
|
|
? Translator.SettingsHome_StorageEmptySummary
|
|
: string.Format(Translator.SettingsStorage_TotalUsage, totalStorageBytes.GetBytesReadable());
|
|
|
|
if (!string.IsNullOrWhiteSpace(SearchQuery))
|
|
{
|
|
UpdateSearchSuggestions(SearchQuery);
|
|
}
|
|
});
|
|
}
|
|
|
|
private void InitializeQuickSettings()
|
|
{
|
|
_isInitializingSettings = true;
|
|
InitializeColors();
|
|
InitializeLanguageOptions();
|
|
InitializeAppearanceOptions();
|
|
_isInitializingSettings = false;
|
|
}
|
|
|
|
private void InitializeLanguageOptions()
|
|
{
|
|
AvailableLanguages = _translationService.GetAvailableLanguages();
|
|
SelectedLanguage = AvailableLanguages.FirstOrDefault(language => language.Language == _preferencesService.CurrentLanguage)
|
|
?? AvailableLanguages.FirstOrDefault();
|
|
}
|
|
|
|
private void InitializeColors()
|
|
{
|
|
Colors.Clear();
|
|
|
|
foreach (var color in _newThemeService.GetAvailableAccountColors().Distinct(StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
Colors.Add(new AppColorViewModel(color));
|
|
}
|
|
|
|
var systemAccentColor = _newThemeService.GetSystemAccentColorHex();
|
|
|
|
if (Colors.All(color => !string.Equals(color.Hex, systemAccentColor, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
Colors.Add(new AppColorViewModel(systemAccentColor, true));
|
|
}
|
|
else
|
|
{
|
|
var matchingAccentColor = Colors.First(color => string.Equals(color.Hex, systemAccentColor, StringComparison.OrdinalIgnoreCase));
|
|
Colors.Remove(matchingAccentColor);
|
|
Colors.Add(new AppColorViewModel(systemAccentColor, true));
|
|
}
|
|
}
|
|
|
|
private void InitializeAppearanceOptions()
|
|
{
|
|
_isAppearanceSelectionPaused = true;
|
|
|
|
var currentAccentColor = _newThemeService.AccentColor;
|
|
|
|
if (!string.IsNullOrWhiteSpace(currentAccentColor) &&
|
|
Colors.All(color => !string.Equals(color.Hex, currentAccentColor, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
Colors.Insert(0, new AppColorViewModel(currentAccentColor));
|
|
}
|
|
|
|
SelectedElementTheme = ElementThemes.FirstOrDefault(theme => theme.NativeTheme == _newThemeService.RootTheme)
|
|
?? ElementThemes.LastOrDefault();
|
|
|
|
if (string.IsNullOrWhiteSpace(currentAccentColor))
|
|
{
|
|
SelectedAppColor = Colors.LastOrDefault(color => color.IsAccentColor) ?? Colors.LastOrDefault();
|
|
UseAccentColor = true;
|
|
}
|
|
else
|
|
{
|
|
SelectedAppColor = Colors.FirstOrDefault(color => string.Equals(color.Hex, currentAccentColor, StringComparison.OrdinalIgnoreCase))
|
|
?? Colors.FirstOrDefault();
|
|
UseAccentColor = SelectedAppColor?.IsAccentColor == true;
|
|
}
|
|
|
|
_isAppearanceSelectionPaused = false;
|
|
}
|
|
|
|
private List<IAccountProviderDetailViewModel> CreateAccountItems(List<MailAccount> accounts)
|
|
{
|
|
var groupedAccounts = accounts
|
|
.OrderBy(account => account.MergedInboxId == null ? 1 : 0)
|
|
.ThenBy(account => account.Order)
|
|
.ThenBy(account => account.Name)
|
|
.GroupBy(account => account.MergedInboxId);
|
|
var accountItems = new List<IAccountProviderDetailViewModel>();
|
|
|
|
foreach (var accountGroup in groupedAccounts)
|
|
{
|
|
if (accountGroup.Key == null)
|
|
{
|
|
accountItems.AddRange(accountGroup.Select(CreateAccountProviderDetails));
|
|
continue;
|
|
}
|
|
|
|
var mergedInbox = accountGroup.First().MergedInbox;
|
|
var holdingAccounts = accountGroup
|
|
.Select(CreateAccountProviderDetails)
|
|
.ToList();
|
|
var mergedAccount = new MergedAccountProviderDetailViewModel(mergedInbox, holdingAccounts)
|
|
{
|
|
ProviderDetail = holdingAccounts.FirstOrDefault()?.ProviderDetail
|
|
};
|
|
|
|
accountItems.Add(mergedAccount);
|
|
}
|
|
|
|
return accountItems;
|
|
}
|
|
|
|
private AccountProviderDetailViewModel CreateAccountProviderDetails(MailAccount account)
|
|
{
|
|
var provider = _providerService.GetProviderDetail(account.ProviderType);
|
|
return new AccountProviderDetailViewModel(provider, account);
|
|
}
|
|
|
|
partial void OnSelectedLanguageChanged(AppLanguageModel value)
|
|
{
|
|
if (_isInitializingSettings || value == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_ = ApplyLanguageAsync(value);
|
|
}
|
|
|
|
partial void OnSelectedElementThemeChanged(ElementThemeContainer value)
|
|
{
|
|
if (_isInitializingSettings || value == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_newThemeService.RootTheme = value.NativeTheme;
|
|
}
|
|
|
|
partial void OnSelectedAppColorChanged(AppColorViewModel value)
|
|
{
|
|
if (_isInitializingSettings || _isAppearanceSelectionPaused || value == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_isAppearanceSelectionPaused = true;
|
|
UseAccentColor = value.IsAccentColor;
|
|
_isAppearanceSelectionPaused = false;
|
|
|
|
_newThemeService.AccentColor = value.Hex;
|
|
}
|
|
|
|
partial void OnUseAccentColorChanged(bool value)
|
|
{
|
|
if (_isInitializingSettings || _isAppearanceSelectionPaused || Colors.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var accentColor = Colors.LastOrDefault(color => color.IsAccentColor);
|
|
var fallbackColor = Colors.FirstOrDefault(color => !color.IsAccentColor) ?? Colors.FirstOrDefault();
|
|
var targetColor = value ? accentColor : SelectedAppColor?.IsAccentColor == true ? fallbackColor : SelectedAppColor;
|
|
|
|
if (targetColor == null || ReferenceEquals(targetColor, SelectedAppColor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_isAppearanceSelectionPaused = true;
|
|
SelectedAppColor = targetColor;
|
|
_isAppearanceSelectionPaused = false;
|
|
|
|
_newThemeService.AccentColor = targetColor.Hex;
|
|
}
|
|
|
|
private async Task ApplyLanguageAsync(AppLanguageModel language)
|
|
{
|
|
await _translationService.InitializeLanguageAsync(language.Language);
|
|
}
|
|
|
|
// Wino Account message recipients
|
|
|
|
protected override void RegisterRecipients()
|
|
{
|
|
base.RegisterRecipients();
|
|
|
|
Messenger.Register<WinoAccountProfileUpdatedMessage>(this);
|
|
Messenger.Register<WinoAccountProfileDeletedMessage>(this);
|
|
Messenger.Register<WinoAccountAddOnPurchasedMessage>(this);
|
|
}
|
|
|
|
protected override void UnregisterRecipients()
|
|
{
|
|
base.UnregisterRecipients();
|
|
|
|
Messenger.Unregister<WinoAccountProfileUpdatedMessage>(this);
|
|
Messenger.Unregister<WinoAccountProfileDeletedMessage>(this);
|
|
Messenger.Unregister<WinoAccountAddOnPurchasedMessage>(this);
|
|
}
|
|
|
|
public void Receive(WinoAccountProfileUpdatedMessage message)
|
|
=> _ = LoadWinoAccountAsync();
|
|
|
|
public void Receive(WinoAccountProfileDeletedMessage message)
|
|
=> _ = ResetWinoAccountStateAsync();
|
|
|
|
public void Receive(WinoAccountAddOnPurchasedMessage message)
|
|
=> _ = LoadWinoAccountAsync();
|
|
|
|
// Wino Account hero card commands and helpers
|
|
|
|
[RelayCommand]
|
|
private async Task WinoAccountRegisterAsync()
|
|
{
|
|
var account = await _dialogService.ShowWinoAccountRegistrationDialogAsync();
|
|
if (account == null) return;
|
|
|
|
_dialogService.InfoBarMessage(Translator.GeneralTitle_Info,
|
|
string.Format(Translator.WinoAccount_RegisterSuccessMessage, account.Email),
|
|
InfoBarMessageType.Success);
|
|
await LoadWinoAccountAsync();
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task WinoAccountSignInAsync()
|
|
{
|
|
var account = await _dialogService.ShowWinoAccountLoginDialogAsync();
|
|
if (account == null) return;
|
|
|
|
_dialogService.InfoBarMessage(Translator.GeneralTitle_Info,
|
|
string.Format(Translator.WinoAccount_LoginSuccessMessage, account.Email),
|
|
InfoBarMessageType.Success);
|
|
await LoadWinoAccountAsync();
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task WinoAccountSignOutAsync()
|
|
{
|
|
var account = await _profileService.GetActiveAccountAsync().ConfigureAwait(false);
|
|
if (account == null) return;
|
|
|
|
await _profileService.SignOutAsync().ConfigureAwait(false);
|
|
|
|
_dialogService.InfoBarMessage(Translator.GeneralTitle_Info,
|
|
string.Format(Translator.WinoAccount_SignOut_SuccessMessage, account.Email),
|
|
InfoBarMessageType.Success);
|
|
await ResetWinoAccountStateAsync();
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task OpenBuyAiPackPageAsync() => await _nativeAppService.LaunchUriAsync(new Uri(BuyAiPackUrl));
|
|
|
|
[RelayCommand]
|
|
private void NavigateToWinoAccountManagement()
|
|
=> NavigateSubDetail(WinoPage.WinoAccountManagementPage);
|
|
|
|
private async Task LoadWinoAccountAsync()
|
|
{
|
|
try
|
|
{
|
|
var cachedAccount = await _profileService.GetActiveAccountAsync().ConfigureAwait(false);
|
|
var cachedAddOns = await _profileService.GetCachedAddOnSnapshotAsync().ConfigureAwait(false);
|
|
|
|
if (cachedAccount != null)
|
|
{
|
|
await ApplyWinoAccountStateAsync(cachedAccount.Email, cachedAccount.AccountStatus).ConfigureAwait(false);
|
|
UpdateAiPackState(cachedAddOns);
|
|
}
|
|
|
|
await ExecuteUIThread(() => IsWinoAccountBusy = cachedAccount == null);
|
|
|
|
var account = await _profileService.GetAuthenticatedAccountAsync().ConfigureAwait(false);
|
|
if (account == null)
|
|
{
|
|
await ResetWinoAccountStateAsync();
|
|
return;
|
|
}
|
|
|
|
var aiStatusResponse = await _profileService.GetAiStatusAsync().ConfigureAwait(false);
|
|
var profileRefreshResult = await _profileService.RefreshProfileAsync().ConfigureAwait(false);
|
|
|
|
var resolvedAccount = profileRefreshResult.IsSuccess && profileRefreshResult.Account != null
|
|
? profileRefreshResult.Account
|
|
: account;
|
|
|
|
await ApplyWinoAccountStateAsync(resolvedAccount.Email, resolvedAccount.AccountStatus).ConfigureAwait(false);
|
|
|
|
if (aiStatusResponse.IsSuccess)
|
|
{
|
|
UpdateAiPackState(aiStatusResponse.Result);
|
|
}
|
|
else
|
|
{
|
|
UpdateAiPackState(cachedAddOns);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
await ResetWinoAccountStateAsync();
|
|
}
|
|
finally
|
|
{
|
|
await ExecuteUIThread(() => IsWinoAccountBusy = false);
|
|
}
|
|
}
|
|
|
|
private async Task ApplyWinoAccountStateAsync(string email, string status)
|
|
{
|
|
await ExecuteUIThread(() =>
|
|
{
|
|
IsWinoAccountSignedIn = true;
|
|
WinoAccountEmail = email;
|
|
WinoAccountStatusText = string.Format(Translator.WinoAccount_Management_StatusLabel, status);
|
|
});
|
|
}
|
|
|
|
private async Task ResetWinoAccountStateAsync()
|
|
{
|
|
await ExecuteUIThread(() =>
|
|
{
|
|
IsWinoAccountSignedIn = false;
|
|
WinoAccountEmail = string.Empty;
|
|
WinoAccountStatusText = string.Empty;
|
|
HasAiPack = false;
|
|
AiPackStateText = Translator.WinoAccount_Management_AiPackInactive;
|
|
AiUsageSummary = string.Empty;
|
|
AiBillingPeriodSummary = string.Empty;
|
|
AiUsagePercent = 0;
|
|
});
|
|
}
|
|
|
|
private void UpdateAiPackState(AiStatusResultDto aiStatus)
|
|
{
|
|
UpdateAiPackState(
|
|
aiStatus?.HasAiPack == true,
|
|
aiStatus?.Used,
|
|
aiStatus?.MonthlyLimit,
|
|
aiStatus?.Remaining,
|
|
aiStatus?.CurrentPeriodStartUtc,
|
|
aiStatus?.CurrentPeriodEndUtc);
|
|
}
|
|
|
|
private void UpdateAiPackState(WinoAccountAddOnSnapshot addOnSnapshot)
|
|
{
|
|
var remaining = addOnSnapshot?.HasAiPack == true && addOnSnapshot.UsageLimit is int limit && addOnSnapshot.UsageCount is int used
|
|
? limit - used
|
|
: (int?)null;
|
|
|
|
UpdateAiPackState(
|
|
addOnSnapshot?.HasAiPack == true,
|
|
addOnSnapshot?.UsageCount,
|
|
addOnSnapshot?.UsageLimit,
|
|
remaining,
|
|
addOnSnapshot?.BillingPeriodStartUtc,
|
|
addOnSnapshot?.BillingPeriodEndUtc);
|
|
}
|
|
|
|
private void UpdateAiPackState(bool hasAiPack, int? used, int? limit, int? remaining, DateTimeOffset? periodStart, DateTimeOffset? periodEnd)
|
|
{
|
|
var usageText = Translator.WinoAccount_Management_AiPackUnknownUsage;
|
|
var billingText = string.Empty;
|
|
var usagePercent = 0d;
|
|
|
|
if (hasAiPack && used is int usageCount && limit is int usageLimit && remaining is int remainingCount)
|
|
{
|
|
usageText = string.Format(Translator.WinoAccount_Management_AiPackUsage, usageCount, usageLimit, remainingCount);
|
|
usagePercent = usageLimit > 0 ? (double)usageCount / usageLimit * 100 : 0;
|
|
}
|
|
|
|
if (hasAiPack && periodStart is DateTimeOffset billingStart && periodEnd is DateTimeOffset billingEnd)
|
|
{
|
|
billingText = string.Format(Translator.WinoAccount_Management_AiPackBillingPeriod, billingStart.LocalDateTime, billingEnd.LocalDateTime);
|
|
}
|
|
|
|
_ = ExecuteUIThread(() =>
|
|
{
|
|
HasAiPack = hasAiPack;
|
|
AiPackStateText = hasAiPack
|
|
? Translator.WinoAccount_Management_AiPackActive
|
|
: Translator.WinoAccount_Management_AiPackInactive;
|
|
AiUsageSummary = hasAiPack ? usageText : string.Empty;
|
|
AiBillingPeriodSummary = hasAiPack ? billingText : string.Empty;
|
|
AiUsagePercent = usagePercent;
|
|
});
|
|
}
|
|
|
|
[RelayCommand]
|
|
public void NavigateSubDetail(object type)
|
|
{
|
|
if (type is WinoPage pageType)
|
|
{
|
|
var pageInfo = SettingsNavigationInfoProvider.GetInfo(pageType, AccountSummaryText);
|
|
Messenger.Send(new BreadcrumbNavigationRequested(pageInfo.Title, pageType));
|
|
}
|
|
}
|
|
|
|
[RelayCommand]
|
|
private async Task NavigateExternalAsync(object target)
|
|
{
|
|
if (target is not string stringTarget || string.IsNullOrWhiteSpace(stringTarget))
|
|
return;
|
|
|
|
if (stringTarget == "Store")
|
|
{
|
|
await _storeRatingService.LaunchStorePageForReviewAsync();
|
|
return;
|
|
}
|
|
|
|
await _nativeAppService.LaunchUriAsync(new Uri(stringTarget));
|
|
}
|
|
}
|