refactor launchgame resources

Co-authored-by: LinkChou <linkchou@yandex.com>

.github/ISSUE_TEMPLATE/CHS-bug-report.yml

@@ -19,7 +19,7 @@ body:
         - label: 我已阅读 Snap Hutao 文档中的[常见问题](https://hut.ao/advanced/FAQ.html)和[常见程序异常](https://hut.ao/advanced/exceptions.html)，我的问题没有在文档中得到解答
           required: true
 
-        - label: 我知道文档站的导航栏中有**搜索功能**，且已经搜索过相关关键词
+        - label: 我知道[文档站](https://hut.ao/zh/menu.html)的导航栏中有**搜索功能**，且已经搜索过相关关键词
           required: true
 
         - label: 我的问题不是[已完成](https://github.com/DGP-Studio/Snap.Hutao/issues?q=is%3Aopen+is%3Aissue+label%3A%E5%B7%B2%E5%AE%8C%E6%88%90)的问题也不是一个别人已发布的**重复的**问题

.github/ISSUE_TEMPLATE/CHS-feature-request.yml

@@ -1,7 +1,7 @@
-name: 功能请求 
+name: 功能请求
 description: 通过这个议题来向开发团队分享你的想法
 title: "[Feat]: 在这里填写一个合适的标题"
-labels: ["功能", "needs-triage", "priority:none"]
+labels: ["feature request", "needs-triage", "priority:none"]
 assignees:
   - Lightczx
 body:
@@ -24,4 +24,4 @@ body:
       label: 想要实现或优化的功能
       description: 详细的描述一下你想要的功能，描述的越具体，采纳的可能性越高
     validations:
-      required: true
+      required: true

.github/ISSUE_TEMPLATE/ENG-feature-request.yml

@@ -1,7 +1,7 @@
 name: Feature Request [English Form]
 description: Tell us about your thought
 title: "[Feat]: Place your title here"
-labels: ["功能", "needs-triage", "priority:none"]
+labels: ["feature request", "needs-triage", "priority:none"]
 assignees:
   - Lightczx
 body:
@@ -22,6 +22,6 @@ body:
     id: req
     attributes:
       label: Detail of the Feature
-      description: Descripbe the feaure in detail. The more detailed and convincing the desciprtion the more likyly feature will be accepted. 
+      description: Descripbe the feaure in detail. The more detailed and convincing the desciprtion the more likyly feature will be accepted.
     validations:
-      required: true
+      required: true

.github/workflows/alpha.yml

@@ -64,12 +64,10 @@ jobs:
           > 该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
 
           > [!TIP]
-          > 普通用户请[点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/)下载最新的稳定版本
+          > 普通用户请 [点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/) 下载最新的稳定版本
 
           > [!IMPORTANT]
-          > 请注意，从 Snap Hutao Alpha 2023.12.21.3 开始，我们将使用全新的 CI 证书，原有的 Snap.Hutao.CI.cer 将在几天后过期停止使用。
-          >
-          > 请安装 [DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt) 到 `受信任的根证书颁发机构` 以安装测试版安装包
+          > 请先安装 **[DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt)** 到 **受信任的根证书颁发机构** 以安装测试版安装包
           "
 
           echo $summary >> $Env:GITHUB_STEP_SUMMARY
@@ -111,12 +109,10 @@ jobs:
           > 该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
 
           > [!TIP]
-          > 普通用户请[点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/)下载最新的稳定版本
+          > 普通用户请 [点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/) 下载最新的稳定版本
 
           > [!IMPORTANT]
-          > 请注意，从 Snap Hutao Alpha 2023.12.21.3 开始，我们将使用全新的 CI 证书，原有的 Snap.Hutao.CI.cer 将在几天后过期停止使用。
-          >
-          > 请安装 [DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt) 到 `受信任的根证书颁发机构` 以安装测试版安装包
+          > 请先安装 **[DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt)** 到 **受信任的根证书颁发机构** 以安装测试版安装包
           "
 
           echo $summary >> $Env:GITHUB_STEP_SUMMARY

src/Snap.Hutao/Snap.Hutao/App.xaml.cs

@@ -3,6 +3,7 @@
 
 using Microsoft.UI.Xaml;
 using Microsoft.Windows.AppLifecycle;
+using Microsoft.Windows.AppNotifications;
 using Snap.Hutao.Core;
 using Snap.Hutao.Core.ExceptionService;
 using Snap.Hutao.Core.LifeCycle;
@@ -68,6 +69,10 @@ public sealed partial class App : Application
     {
         try
         {
+            // Important: You must call AppNotificationManager::Default().Register
+            // before calling AppInstance.GetCurrent.GetActivatedEventArgs.
+            AppNotificationManager.Default.NotificationInvoked += activation.NotificationInvoked;
+            AppNotificationManager.Default.Register();
             AppActivationArguments activatedEventArgs = AppInstance.GetCurrent().GetActivatedEventArgs();
 
             if (serviceProvider.GetRequiredService<PrivateNamedPipeClient>().TryRedirectActivationTo(activatedEventArgs))
@@ -81,14 +86,7 @@ public sealed partial class App : Application
             LogDiagnosticInformation();
 
             // Manually invoke
-            HutaoActivationArguments hutaoArgs = HutaoActivationArguments.FromAppActivationArguments(activatedEventArgs);
-            if (hutaoArgs.Kind is HutaoActivationKind.Toast)
-            {
-                Exit();
-                return;
-            }
-
-            activation.Activate(hutaoArgs);
+            activation.Activate(HutaoActivationArguments.FromAppActivationArguments(activatedEventArgs));
             activation.PostInitialization();
         }
         catch (Exception ex)

src/Snap.Hutao/Snap.Hutao/Control/Behavior/InfoBarDelayCloseBehavior.cs

@@ -0,0 +1,51 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using CommunityToolkit.WinUI.Behaviors;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Snap.Hutao.Control.Behavior;
+
+[SuppressMessage("", "CA1001")]
+[DependencyProperty("MilliSecondsDelay", typeof(int))]
+internal sealed partial class InfoBarDelayCloseBehavior : BehaviorBase<InfoBar>
+{
+    private readonly CancellationTokenSource closeTokenSource = new();
+
+    protected override void OnAssociatedObjectLoaded()
+    {
+        AssociatedObject.Closed += OnInfoBarClosed;
+        if (MilliSecondsDelay > 0)
+        {
+            DelayCoreAsync().SafeForget();
+        }
+    }
+
+    private async ValueTask DelayCoreAsync()
+    {
+        try
+        {
+            await Task.Delay(MilliSecondsDelay, closeTokenSource.Token).ConfigureAwait(true);
+        }
+        catch
+        {
+            return;
+        }
+
+        if (AssociatedObject is not null)
+        {
+            AssociatedObject.IsOpen = false;
+        }
+    }
+
+    private void OnInfoBarClosed(InfoBar infoBar, InfoBarClosedEventArgs args)
+    {
+        if (args.Reason is InfoBarCloseReason.CloseButton)
+        {
+            closeTokenSource.Cancel();
+        }
+
+        AssociatedObject.Closed -= OnInfoBarClosed;
+    }
+}

src/Snap.Hutao/Snap.Hutao/Control/Image/CachedImage.cs

@@ -1,10 +1,15 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Microsoft.UI.Xaml.Media.Imaging;
 using Snap.Hutao.Control.Extension;
 using Snap.Hutao.Core.Caching;
 using Snap.Hutao.Core.ExceptionService;
+using Snap.Hutao.Core.IO.DataTransfer;
+using System.IO;
 using System.Runtime.InteropServices;
+using Windows.Graphics.Imaging;
+using Windows.Storage.Streams;
 
 namespace Snap.Hutao.Control.Image;
 
@@ -12,7 +17,9 @@ namespace Snap.Hutao.Control.Image;
 /// 缓存图像
 /// </summary>
 [HighQuality]
-internal sealed class CachedImage : Implementation.ImageEx
+[DependencyProperty("SourceName", typeof(string), "Unknown")]
+[DependencyProperty("CachedName", typeof(string), "Unknown")]
+internal sealed partial class CachedImage : Implementation.ImageEx
 {
     /// <summary>
     /// 构造一个新的缓存图像
@@ -26,12 +33,14 @@ internal sealed class CachedImage : Implementation.ImageEx
     /// <inheritdoc/>
     protected override async Task<Uri?> ProvideCachedResourceAsync(Uri imageUri, CancellationToken token)
     {
+        SourceName = Path.GetFileName(imageUri.ToString());
         IImageCache imageCache = this.ServiceProvider().GetRequiredService<IImageCache>();
 
         try
         {
             HutaoException.ThrowIf(string.IsNullOrEmpty(imageUri.Host), SH.ControlImageCachedImageInvalidResourceUri);
             string file = await imageCache.GetFileFromCacheAsync(imageUri).ConfigureAwait(true); // BitmapImage need to be created by main thread.
+            CachedName = Path.GetFileName(file);
             token.ThrowIfCancellationRequested(); // check token state to determine whether the operation should be canceled.
             return file.ToUri();
         }
@@ -42,4 +51,27 @@ internal sealed class CachedImage : Implementation.ImageEx
             return default;
         }
     }
-}
+
+    [Command("CopyToClipboardCommand")]
+    private async Task CopyToClipboard()
+    {
+        if (Image is Microsoft.UI.Xaml.Controls.Image { Source: BitmapImage bitmap })
+        {
+            using (FileStream netStream = File.OpenRead(bitmap.UriSource.LocalPath))
+            {
+                using (IRandomAccessStream fxStream = netStream.AsRandomAccessStream())
+                {
+                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fxStream);
+                    SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
+                    using (InMemoryRandomAccessStream memory = new())
+                    {
+                        BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, memory);
+                        encoder.SetSoftwareBitmap(softwareBitmap);
+                        await encoder.FlushAsync();
+                        Ioc.Default.GetRequiredService<IClipboardProvider>().SetBitmap(memory);
+                    }
+                }
+            }
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Control/Image/CachedImage.xaml

@@ -1,4 +1,4 @@
-<ResourceDictionary
+<ResourceDictionary
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:shci="using:Snap.Hutao.Control.Image">
@@ -14,6 +14,13 @@
                         BorderBrush="{TemplateBinding BorderBrush}"
                         BorderThickness="{TemplateBinding BorderThickness}"
                         CornerRadius="{TemplateBinding CornerRadius}">
+                        <Grid.ContextFlyout>
+                            <MenuFlyout>
+                                <MenuFlyoutItem IsEnabled="False" Text="{TemplateBinding SourceName}"/>
+                                <MenuFlyoutItem IsEnabled="False" Text="{TemplateBinding CachedName}"/>
+                                <MenuFlyoutItem Command="{Binding CopyToClipboardCommand, RelativeSource={RelativeSource TemplatedParent}}" Text="复制图像"/>
+                            </MenuFlyout>
+                        </Grid.ContextFlyout>
                         <Image
                             Name="PlaceholderImage"
                             Margin="{TemplateBinding PlaceholderMargin}"

src/Snap.Hutao/Snap.Hutao/Control/Loading.xaml

@@ -24,7 +24,7 @@
                             x:Name="ContentGrid"
                             HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                             VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
-                            x:Load="False">
+                            x:Load="True">
                             <ContentPresenter.RenderTransform>
                                 <CompositeTransform/>
                             </ContentPresenter.RenderTransform>

src/Snap.Hutao/Snap.Hutao/Control/ScopedPage.cs

@@ -5,7 +5,6 @@ using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using Microsoft.UI.Xaml.Markup;
 using Microsoft.UI.Xaml.Navigation;
-using Snap.Hutao.Core.Abstraction;
 using Snap.Hutao.Service.Navigation;
 using Snap.Hutao.View.Helper;
 using Snap.Hutao.ViewModel.Abstraction;

src/Snap.Hutao/Snap.Hutao/Control/Selector/InfoBarTemplateSelector.cs

@@ -0,0 +1,25 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Snap.Hutao.Service.Notification;
+
+namespace Snap.Hutao.Control.Selector;
+
+internal sealed class InfoBarTemplateSelector : DataTemplateSelector
+{
+    public DataTemplate ActionButtonEnabled { get; set; } = default!;
+
+    public DataTemplate ActionButtonDisabled { get; set; } = default!;
+
+    protected override DataTemplate SelectTemplateCore(object item, DependencyObject container)
+    {
+        if (item is InfoBarOptions { ActionButtonContent: { }, ActionButtonCommand: { } })
+        {
+            return ActionButtonEnabled;
+        }
+
+        return ActionButtonDisabled;
+    }
+}

src/Snap.Hutao/Snap.Hutao/Control/SizeRestrictedContentControl.cs

@@ -21,8 +21,8 @@ internal sealed partial class SizeRestrictedContentControl : ContentControl
             element.Measure(availableSize);
             Size contentDesiredSize = element.DesiredSize;
             Size contentActualOrDesiredSize = new(
-                Math.Max(element.ActualWidth, contentDesiredSize.Width),
-                Math.Max(element.ActualHeight, contentDesiredSize.Height));
+                Math.Min(Math.Max(element.ActualWidth, contentDesiredSize.Width), availableSize.Width),
+                Math.Min(Math.Max(element.ActualHeight, contentDesiredSize.Height), availableSize.Height));
 
             if (IsWidthRestricted)
             {

src/Snap.Hutao/Snap.Hutao/Control/Theme/Converter.xaml

@@ -10,6 +10,7 @@
     <shmmc:AchievementIconConverter x:Key="AchievementIconConverter"/>
     <shmmc:AvatarCardConverter x:Key="AvatarCardConverter"/>
     <shmmc:AvatarIconConverter x:Key="AvatarIconConverter"/>
+    <shmmc:AvatarIconCircleConverter x:Key="AvatarIconCircleConverter"/>
     <shmmc:AvatarNameCardPicConverter x:Key="AvatarNameCardPicConverter"/>
     <shmmc:AvatarSideIconConverter x:Key="AvatarSideIconConverter"/>
     <shmmc:DescriptionsParametersDescriptor x:Key="DescParamDescriptor"/>

src/Snap.Hutao/Snap.Hutao/Control/Theme/CornerRadius.xaml

@@ -2,4 +2,5 @@
     <CornerRadius x:Key="ControlCornerRadiusTop">4,4,0,0</CornerRadius>
     <CornerRadius x:Key="ControlCornerRadiusBottom">0,0,4,4</CornerRadius>
     <CornerRadius x:Key="ControlCornerRadiusTopRightAndBottomLeft">0,4,0,4</CornerRadius>
+    <CornerRadius x:Key="CornerRadiusAll16">16</CornerRadius>
 </ResourceDictionary>

src/Snap.Hutao/Snap.Hutao/Control/Theme/ItemsPanelTemplate.xaml

@@ -23,6 +23,9 @@
     <ItemsPanelTemplate x:Key="HorizontalStackPanelSpacing4Template">
         <StackPanel Orientation="Horizontal" Spacing="4"/>
     </ItemsPanelTemplate>
+    <ItemsPanelTemplate x:Key="HorizontalStackPanelSpacing6Template">
+        <StackPanel Orientation="Horizontal" Spacing="6"/>
+    </ItemsPanelTemplate>
     <ItemsPanelTemplate x:Key="StackPanelSpacing4Template">
         <StackPanel Spacing="4"/>
     </ItemsPanelTemplate>

src/Snap.Hutao/Snap.Hutao/Core/IO/Http/Proxy/HttpProxyUsingSystemProxy.cs

@@ -3,7 +3,6 @@
 
 using CommunityToolkit.Mvvm.ComponentModel;
 using Snap.Hutao.Win32.Registry;
-using System.Linq.Expressions;
 using System.Net;
 using System.Reflection;
 

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/AppActivation.cs

@@ -1,9 +1,9 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using CommunityToolkit.WinUI.Notifications;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.UI.Xaml;
+using Microsoft.Windows.AppNotifications;
 using Snap.Hutao.Core.LifeCycle.InterProcess;
 using Snap.Hutao.Core.Setting;
 using Snap.Hutao.Core.Shell;
@@ -11,7 +11,6 @@ using Snap.Hutao.Core.Windowing;
 using Snap.Hutao.Core.Windowing.HotKey;
 using Snap.Hutao.Core.Windowing.NotifyIcon;
 using Snap.Hutao.Service;
-using Snap.Hutao.Service.DailyNote;
 using Snap.Hutao.Service.Discord;
 using Snap.Hutao.Service.Hutao;
 using Snap.Hutao.Service.Job;
@@ -37,12 +36,10 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
     public const string ImportUIAFFromClipboard = nameof(ImportUIAFFromClipboard);
 
     private const string CategoryAchievement = "ACHIEVEMENT";
-    private const string CategoryDailyNote = "DAILYNOTE";
     private const string UrlActionImport = "/IMPORT";
-    private const string UrlActionRefresh = "/REFRESH";
 
-    private readonly IServiceProvider serviceProvider;
     private readonly ICurrentXamlWindowReference currentWindowReference;
+    private readonly IServiceProvider serviceProvider;
     private readonly ITaskContext taskContext;
 
     private readonly SemaphoreSlim activateSemaphore = new(1);
@@ -50,7 +47,47 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
     /// <inheritdoc/>
     public void Activate(HutaoActivationArguments args)
     {
-        HandleActivationAsync(args).SafeForget();
+        HandleActivationExclusiveAsync(args).SafeForget();
+
+        async ValueTask HandleActivationExclusiveAsync(HutaoActivationArguments args)
+        {
+            await taskContext.SwitchToBackgroundAsync();
+
+            if (activateSemaphore.CurrentCount > 0)
+            {
+                using (await activateSemaphore.EnterAsync().ConfigureAwait(false))
+                {
+                    switch (args.Kind)
+                    {
+                        case HutaoActivationKind.Protocol:
+                            {
+                                ArgumentNullException.ThrowIfNull(args.ProtocolActivatedUri);
+                                await HandleProtocolActivationAsync(args.ProtocolActivatedUri, args.IsRedirectTo).ConfigureAwait(false);
+                                break;
+                            }
+
+                        case HutaoActivationKind.Launch:
+                            {
+                                ArgumentNullException.ThrowIfNull(args.LaunchActivatedArguments);
+                                await HandleLaunchActivationAsync(args.IsRedirectTo).ConfigureAwait(false);
+                                break;
+                            }
+
+                        case HutaoActivationKind.AppNotification:
+                            {
+                                ArgumentNullException.ThrowIfNull(args.AppNotificationActivatedArguments);
+                                await HandleAppNotificationActivationAsync(args.AppNotificationActivatedArguments, args.IsRedirectTo).ConfigureAwait(false);
+                                break;
+                            }
+                    }
+                }
+            }
+        }
+    }
+
+    public void NotificationInvoked(AppNotificationManager manager, AppNotificationActivatedEventArgs args)
+    {
+        HandleAppNotificationActivationAsync(args.Arguments, false).SafeForget();
     }
 
     /// <inheritdoc/>
@@ -62,20 +99,23 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
         {
             await taskContext.SwitchToBackgroundAsync();
 
-            serviceProvider.GetRequiredService<PrivateNamedPipeServer>().RunAsync().SafeForget();
-            ToastNotificationManagerCompat.OnActivated += NotificationActivate;
-
             using (await activateSemaphore.EnterAsync().ConfigureAwait(false))
             {
                 // TODO: Introduced in 1.10.2, remove in later version
-                serviceProvider.GetRequiredService<IJumpListInterop>().ClearAsync().SafeForget();
-                serviceProvider.GetRequiredService<IScheduleTaskInterop>().UnregisterAllTasks();
+                {
+                    serviceProvider.GetRequiredService<IJumpListInterop>().ClearAsync().SafeForget();
+                    serviceProvider.GetRequiredService<IScheduleTaskInterop>().UnregisterAllTasks();
+                }
 
                 if (UnsafeLocalSetting.Get(SettingKeys.Major1Minor10Revision0GuideState, GuideState.Language) < GuideState.Completed)
                 {
                     return;
                 }
 
+                serviceProvider.GetRequiredService<PrivateNamedPipeServer>().RunAsync().SafeForget();
+
+                // RegisterHotKey should be called from main thread
+                await taskContext.SwitchToMainThreadAsync();
                 serviceProvider.GetRequiredService<HotKeyOptions>().RegisterAll();
 
                 if (serviceProvider.GetRequiredService<AppOptions>().IsNotifyIconEnabled)
@@ -87,7 +127,18 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
                     _ = serviceProvider.GetRequiredService<NotifyIconController>();
                 }
 
-                serviceProvider.GetRequiredService<IQuartzService>().StartAsync(default).SafeForget();
+                serviceProvider.GetRequiredService<IDiscordService>().SetNormalActivityAsync().SafeForget();
+                serviceProvider.GetRequiredService<IQuartzService>().StartAsync().SafeForget();
+
+                if (serviceProvider.GetRequiredService<IMetadataService>() is IMetadataServiceInitialization metadataServiceInitialization)
+                {
+                    metadataServiceInitialization.InitializeInternalAsync().SafeForget();
+                }
+
+                if (serviceProvider.GetRequiredService<IHutaoUserService>() is IHutaoUserServiceInitialization hutaoUserServiceInitialization)
+                {
+                    hutaoUserServiceInitialization.InitializeInternalAsync().SafeForget();
+                }
             }
         }
     }
@@ -133,55 +184,52 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
         }
     }
 
-    private void NotificationActivate(ToastNotificationActivatedEventArgsCompat args)
+    private async ValueTask HandleProtocolActivationAsync(Uri uri, bool isRedirectTo)
     {
-        ToastArguments toastArgs = ToastArguments.Parse(args.Argument);
+        UriBuilder builder = new(uri);
 
-        if (toastArgs.TryGetValue(Action, out string? action))
-        {
-            if (action == LaunchGame)
-            {
-                _ = toastArgs.TryGetValue(Uid, out string? uid);
-                HandleLaunchGameActionAsync(uid).SafeForget();
-            }
-        }
-    }
+        string category = builder.Host.ToUpperInvariant();
+        string action = builder.Path.ToUpperInvariant();
 
-    private async ValueTask HandleActivationAsync(HutaoActivationArguments args)
-    {
-        await taskContext.SwitchToBackgroundAsync();
-
-        if (activateSemaphore.CurrentCount > 0)
+        // string parameter = builder.Query.ToUpperInvariant();
+        switch (category)
         {
-            using (await activateSemaphore.EnterAsync().ConfigureAwait(false))
-            {
-                await HandleActivationCoreAsync(args).ConfigureAwait(false);
-            }
-        }
-    }
-
-    private async ValueTask HandleActivationCoreAsync(HutaoActivationArguments args)
-    {
-        if (args.Kind is HutaoActivationKind.Protocol)
-        {
-            ArgumentNullException.ThrowIfNull(args.ProtocolActivatedUri);
-            await HandleUrlActivationAsync(args.ProtocolActivatedUri, args.IsRedirectTo).ConfigureAwait(false);
-        }
-        else if (args.Kind is HutaoActivationKind.Launch)
-        {
-            ArgumentNullException.ThrowIfNull(args.LaunchActivatedArguments);
-            switch (args.LaunchActivatedArguments)
-            {
-                default:
+            case CategoryAchievement:
+                {
+                    await WaitMainWindowOrCurrentAsync().ConfigureAwait(false);
+                    if (currentWindowReference.Window is not MainWindow)
                     {
-                        await HandleNormalLaunchActionAsync(args.IsRedirectTo).ConfigureAwait(false);
-                        break;
+                        // TODO: Send notification to hint?
+                        return;
                     }
-            }
+
+                    switch (action)
+                    {
+                        case UrlActionImport:
+                            {
+                                await taskContext.SwitchToMainThreadAsync();
+
+                                INavigationAwaiter navigationAwaiter = new NavigationExtra(ImportUIAFFromClipboard);
+                                await serviceProvider
+                                    .GetRequiredService<INavigationService>()
+                                    .NavigateAsync<View.Page.AchievementPage>(navigationAwaiter, true)
+                                    .ConfigureAwait(false);
+                                break;
+                            }
+                    }
+
+                    break;
+                }
+
+            default:
+                {
+                    await HandleLaunchActivationAsync(isRedirectTo).ConfigureAwait(false);
+                    break;
+                }
         }
     }
 
-    private async ValueTask HandleNormalLaunchActionAsync(bool isRedirectTo)
+    private async ValueTask HandleLaunchActivationAsync(bool isRedirectTo)
     {
         if (!isRedirectTo)
         {
@@ -213,6 +261,22 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
         await WaitMainWindowOrCurrentAsync().ConfigureAwait(false);
     }
 
+    private async ValueTask HandleAppNotificationActivationAsync(IDictionary<string, string> arguments, bool isRedirectTo)
+    {
+        if (arguments.TryGetValue(Action, out string? action))
+        {
+            if (action == LaunchGame)
+            {
+                _ = arguments.TryGetValue(Uid, out string? uid);
+                await HandleLaunchGameActionAsync(uid).ConfigureAwait(false);
+            }
+        }
+        else
+        {
+            await HandleLaunchActivationAsync(isRedirectTo).ConfigureAwait(false);
+        }
+    }
+
     private async ValueTask WaitMainWindowOrCurrentAsync()
     {
         if (currentWindowReference.Window is { } window)
@@ -229,100 +293,5 @@ internal sealed partial class AppActivation : IAppActivation, IAppActivationActi
 
         mainWindow.SwitchTo();
         mainWindow.BringToForeground();
-
-        await taskContext.SwitchToBackgroundAsync();
-
-        if (serviceProvider.GetRequiredService<IMetadataService>() is IMetadataServiceInitialization metadataServiceInitialization)
-        {
-            metadataServiceInitialization.InitializeInternalAsync().SafeForget();
-        }
-
-        if (serviceProvider.GetRequiredService<IHutaoUserService>() is IHutaoUserServiceInitialization hutaoUserServiceInitialization)
-        {
-            hutaoUserServiceInitialization.InitializeInternalAsync().SafeForget();
-        }
-
-        serviceProvider.GetRequiredService<IDiscordService>().SetNormalActivityAsync().SafeForget();
-    }
-
-    private async ValueTask HandleUrlActivationAsync(Uri uri, bool isRedirectTo)
-    {
-        UriBuilder builder = new(uri);
-
-        string category = builder.Host.ToUpperInvariant();
-        string action = builder.Path.ToUpperInvariant();
-        string parameter = builder.Query.ToUpperInvariant();
-
-        switch (category)
-        {
-            case CategoryAchievement:
-                {
-                    await WaitMainWindowOrCurrentAsync().ConfigureAwait(false);
-                    await HandleAchievementActionAsync(action, parameter, isRedirectTo).ConfigureAwait(false);
-                    break;
-                }
-
-            case CategoryDailyNote:
-                {
-                    await HandleDailyNoteActionAsync(action, parameter, isRedirectTo).ConfigureAwait(false);
-                    break;
-                }
-
-            default:
-                {
-                    await HandleNormalLaunchActionAsync(isRedirectTo).ConfigureAwait(false);
-                    break;
-                }
-        }
-    }
-
-    private async ValueTask HandleAchievementActionAsync(string action, string parameter, bool isRedirectTo)
-    {
-        _ = parameter;
-        _ = isRedirectTo;
-        switch (action)
-        {
-            case UrlActionImport:
-                {
-                    await taskContext.SwitchToMainThreadAsync();
-
-                    INavigationAwaiter navigationAwaiter = new NavigationExtra(ImportUIAFFromClipboard);
-                    await serviceProvider
-                        .GetRequiredService<INavigationService>()
-                        .NavigateAsync<View.Page.AchievementPage>(navigationAwaiter, true)
-                        .ConfigureAwait(false);
-                    break;
-                }
-        }
-    }
-
-    private async ValueTask HandleDailyNoteActionAsync(string action, string parameter, bool isRedirectTo)
-    {
-        _ = parameter;
-        switch (action)
-        {
-            case UrlActionRefresh:
-                {
-                    try
-                    {
-                        await serviceProvider
-                            .GetRequiredService<IDailyNoteService>()
-                            .RefreshDailyNotesAsync()
-                            .ConfigureAwait(false);
-                    }
-                    catch
-                    {
-                    }
-
-                    // Check if it's redirected.
-                    if (!isRedirectTo)
-                    {
-                        // It's a direct open process, should exit immediately.
-                        Process.GetCurrentProcess().Kill();
-                    }
-
-                    break;
-                }
-        }
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/AppActivationArgumentsExtensions.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 using Microsoft.Windows.AppLifecycle;
+using Microsoft.Windows.AppNotifications;
 using Windows.ApplicationModel.Activation;
 
 namespace Snap.Hutao.Core.LifeCycle;
@@ -12,12 +13,6 @@ namespace Snap.Hutao.Core.LifeCycle;
 [HighQuality]
 internal static class AppActivationArgumentsExtensions
 {
-    /// <summary>
-    /// 尝试获取协议启动的Uri
-    /// </summary>
-    /// <param name="activatedEventArgs">应用程序激活参数</param>
-    /// <param name="uri">协议Uri</param>
-    /// <returns>是否存在协议Uri</returns>
     public static bool TryGetProtocolActivatedUri(this AppActivationArguments activatedEventArgs, [NotNullWhen(true)] out Uri? uri)
     {
         uri = null;
@@ -30,15 +25,10 @@ internal static class AppActivationArgumentsExtensions
         return true;
     }
 
-    /// <summary>
-    /// 尝试获取启动的参数
-    /// </summary>
-    /// <param name="activatedEventArgs">应用程序激活参数</param>
-    /// <param name="arguments">参数</param>
-    /// <returns>是否存在参数</returns>
     public static bool TryGetLaunchActivatedArguments(this AppActivationArguments activatedEventArgs, [NotNullWhen(true)] out string? arguments)
     {
         arguments = null;
+
         if (activatedEventArgs.Data is not ILaunchActivatedEventArgs launchArgs)
         {
             return false;
@@ -47,4 +37,21 @@ internal static class AppActivationArgumentsExtensions
         arguments = launchArgs.Arguments.Trim();
         return true;
     }
+
+    public static bool TryGetAppNotificationActivatedArguments(this AppActivationArguments activatedEventArgs, out string? argument, [NotNullWhen(true)] out IDictionary<string, string>? arguments, [NotNullWhen(true)] out IDictionary<string, string>? userInput)
+    {
+        argument = null;
+        arguments = null;
+        userInput = null;
+
+        if (activatedEventArgs.Data is not AppNotificationActivatedEventArgs appNotificationArgs)
+        {
+            return false;
+        }
+
+        argument = appNotificationArgs.Argument;
+        arguments = appNotificationArgs.Arguments;
+        userInput = appNotificationArgs.UserInput;
+        return true;
+    }
 }

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/HutaoActivationArguments.cs

@@ -1,7 +1,6 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using Microsoft.Extensions.Primitives;
 using Microsoft.Windows.AppLifecycle;
 
 namespace Snap.Hutao.Core.LifeCycle;
@@ -10,14 +9,16 @@ internal sealed class HutaoActivationArguments
 {
     public bool IsRedirectTo { get; set; }
 
-    public bool IsToastActivated { get; set; }
-
     public HutaoActivationKind Kind { get; set; }
 
     public Uri? ProtocolActivatedUri { get; set; }
 
     public string? LaunchActivatedArguments { get; set; }
 
+    public IDictionary<string, string>? AppNotificationActivatedArguments { get; set; }
+
+    public IDictionary<string, string>? AppNotificationActivatedUserInput { get; set; }
+
     public static HutaoActivationArguments FromAppActivationArguments(AppActivationArguments args, bool isRedirected = false)
     {
         HutaoActivationArguments result = new()
@@ -33,15 +34,6 @@ internal sealed class HutaoActivationArguments
                     if (args.TryGetLaunchActivatedArguments(out string? arguments))
                     {
                         result.LaunchActivatedArguments = arguments;
-
-                        foreach (StringSegment segment in new StringTokenizer(arguments, [' ']))
-                        {
-                            if (segment.AsSpan().SequenceEqual("-ToastActivated"))
-                            {
-                                result.Kind = HutaoActivationKind.Toast;
-                                break;
-                            }
-                        }
                     }
 
                     break;
@@ -55,6 +47,19 @@ internal sealed class HutaoActivationArguments
                         result.ProtocolActivatedUri = uri;
                     }
 
+                    break;
+                }
+
+            case ExtendedActivationKind.AppNotification:
+                {
+                    result.Kind = HutaoActivationKind.AppNotification;
+                    if (args.TryGetAppNotificationActivatedArguments(out string? argument, out IDictionary<string, string>? arguments, out IDictionary<string, string>? userInput))
+                    {
+                        result.LaunchActivatedArguments = argument;
+                        result.AppNotificationActivatedArguments = arguments;
+                        result.AppNotificationActivatedUserInput = userInput;
+                    }
+
                     break;
                 }
         }

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/HutaoActivationKind.cs

@@ -7,6 +7,6 @@ internal enum HutaoActivationKind
 {
     None,
     Launch,
-    Toast,
+    AppNotification,
     Protocol,
 }

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/IAppActivation.cs

@@ -1,16 +1,15 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Microsoft.Windows.AppNotifications;
+
 namespace Snap.Hutao.Core.LifeCycle;
 
 internal interface IAppActivation
 {
     void Activate(HutaoActivationArguments args);
 
-    void PostInitialization();
-}
+    void NotificationInvoked(AppNotificationManager manager, AppNotificationActivatedEventArgs args);
 
-internal interface IAppActivationActionHandlersAccess
-{
-    ValueTask HandleLaunchGameActionAsync(string? uid = null);
+    void PostInitialization();
 }

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/IAppActivationActionHandlersAccess.cs

@@ -0,0 +1,9 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.LifeCycle;
+
+internal interface IAppActivationActionHandlersAccess
+{
+    ValueTask HandleLaunchGameActionAsync(string? uid = null);
+}

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/InterProcess/PrivateNamedPipeServer.cs

@@ -13,6 +13,7 @@ internal sealed partial class PrivateNamedPipeServer : IDisposable
 {
     private readonly PrivateNamedPipeMessageDispatcher messageDispatcher;
     private readonly RuntimeOptions runtimeOptions;
+    private readonly ILogger<PrivateNamedPipeServer> logger;
 
     private readonly CancellationTokenSource serverTokenSource = new();
     private readonly SemaphoreSlim serverSemaphore = new(1);
@@ -23,6 +24,7 @@ internal sealed partial class PrivateNamedPipeServer : IDisposable
     {
         messageDispatcher = serviceProvider.GetRequiredService<PrivateNamedPipeMessageDispatcher>();
         runtimeOptions = serviceProvider.GetRequiredService<RuntimeOptions>();
+        logger = serviceProvider.GetRequiredService<ILogger<PrivateNamedPipeServer>>();
 
         PipeSecurity? pipeSecurity = default;
 
@@ -64,6 +66,7 @@ internal sealed partial class PrivateNamedPipeServer : IDisposable
                 try
                 {
                     await serverStream.WaitForConnectionAsync(serverTokenSource.Token).ConfigureAwait(false);
+                    logger.LogInformation("Pipe session created");
                     RunPacketSession(serverStream, serverTokenSource.Token);
                 }
                 catch (OperationCanceledException)
@@ -78,6 +81,7 @@ internal sealed partial class PrivateNamedPipeServer : IDisposable
         while (serverStream.IsConnected && !token.IsCancellationRequested)
         {
             serverStream.ReadPacket(out PipePacketHeader header);
+            logger.LogInformation("Pipe packet: [Type:{Type}] [Command:{Command}]", header.Type, header.Command);
             switch ((header.Type, header.Command))
             {
                 case (PipePacketType.Request, PipePacketCommand.RequestElevationStatus):
@@ -87,6 +91,11 @@ internal sealed partial class PrivateNamedPipeServer : IDisposable
                     break;
                 case (PipePacketType.Request, PipePacketCommand.RedirectActivation):
                     HutaoActivationArguments? hutaoArgs = serverStream.ReadJsonContent<HutaoActivationArguments>(in header);
+                    if (hutaoArgs is not null)
+                    {
+                        logger.LogInformation("Redirect activation: [Kind:{Kind}] [Arguments:{Arguments}]", hutaoArgs.Kind, hutaoArgs.LaunchActivatedArguments);
+                    }
+
                     messageDispatcher.RedirectActivation(hutaoArgs);
                     break;
                 case (PipePacketType.SessionTermination, _):

src/Snap.Hutao/Snap.Hutao/Core/Threading/AsyncBarrier.cs

@@ -25,7 +25,7 @@ internal class AsyncBarrier
     /// <param name="participants">The number of participants.</param>
     public AsyncBarrier(int participants)
     {
-        ArgumentOutOfRangeException.ThrowIfLessThan(participants, 1, "Participants of AsyncBarrier can not be less than 1");
+        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(participants, "Participants of AsyncBarrier must be greater than 0");
         participantCount = participants;
 
         // Allocate the stack so no resizing is necessary.

src/Snap.Hutao/Snap.Hutao/Core/Windowing/NotifyIcon/NotifyIconController.cs

@@ -4,11 +4,11 @@
 using Snap.Hutao.Core.ExceptionService;
 using Snap.Hutao.Win32.Foundation;
 using Snap.Hutao.Win32.UI.WindowsAndMessaging;
+using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 using System.Text;
-using Windows.Storage;
 using static Snap.Hutao.Win32.ConstValues;
 
 namespace Snap.Hutao.Core.Windowing.NotifyIcon;
@@ -26,9 +26,10 @@ internal sealed class NotifyIconController : IDisposable
     {
         lazyMenu = new(() => new(serviceProvider));
 
-        StorageFile iconFile = StorageFile.GetFileFromApplicationUriAsync("ms-appx:///Assets/Logo.ico".ToUri()).AsTask().GetAwaiter().GetResult();
-        icon = new(iconFile.Path);
-        id = Unsafe.As<byte, Guid>(ref MemoryMarshal.GetArrayDataReference(MD5.HashData(Encoding.UTF8.GetBytes(iconFile.Path))));
+        RuntimeOptions runtimeOptions = serviceProvider.GetRequiredService<RuntimeOptions>();
+        string iconPath = Path.Combine(runtimeOptions.InstalledLocation, "Assets/Logo.ico");
+        icon = new(iconPath);
+        id = Unsafe.As<byte, Guid>(ref MemoryMarshal.GetArrayDataReference(MD5.HashData(Encoding.UTF8.GetBytes(iconPath))));
 
         xamlHostWindow = new(serviceProvider);
         xamlHostWindow.MoveAndResize(default);

src/Snap.Hutao/Snap.Hutao/Core/Windowing/WindowExtension.cs

@@ -31,6 +31,12 @@ internal static class WindowExtension
         return WindowControllers.TryGetValue(window, out _);
     }
 
+    public static void UninitializeController<TWindow>(this TWindow window)
+        where TWindow : Window
+    {
+        WindowControllers.Remove(window);
+    }
+
     public static DesktopWindowXamlSource? GetDesktopWindowXamlSource(this Window window)
     {
         if (window.SystemBackdrop is SystemBackdropDesktopWindowXamlSourceAccess access)

src/Snap.Hutao/Snap.Hutao/Core/Windowing/XamlWindowController.cs

@@ -1,7 +1,6 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using CommunityToolkit.WinUI.Notifications;
 using Microsoft.UI;
 using Microsoft.UI.Composition.SystemBackdrops;
 using Microsoft.UI.Content;
@@ -9,6 +8,7 @@ using Microsoft.UI.Input;
 using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
+using Microsoft.Windows.AppNotifications.Builder;
 using Snap.Hutao.Core.LifeCycle;
 using Snap.Hutao.Core.Setting;
 using Snap.Hutao.Core.Windowing.Abstraction;
@@ -99,14 +99,13 @@ internal sealed class XamlWindowController
 
     private void OnWindowClosed(object sender, WindowEventArgs args)
     {
+        serviceProvider.GetRequiredService<AppOptions>().PropertyChanged -= OnOptionsPropertyChanged;
+
         if (XamlLifetime.ApplicationLaunchedWithNotifyIcon && !XamlLifetime.ApplicationExiting)
         {
-            args.Handled = true;
-            window.Hide();
-
             if (!IsNotifyIconVisible())
             {
-                new ToastContentBuilder()
+                new AppNotificationBuilder()
                     .AddText(SH.CoreWindowingNotifyIconPromotedHint)
                     .Show();
             }
@@ -119,16 +118,15 @@ internal sealed class XamlWindowController
 
             GC.Collect(GC.MaxGeneration);
         }
-        else
-        {
-            if (window is IXamlWindowRectPersisted rectPersisted)
-            {
-                SaveOrSkipWindowSize(rectPersisted);
-            }
 
-            subclass?.Dispose();
-            windowNonRudeHWND?.Dispose();
+        if (window is IXamlWindowRectPersisted rectPersisted)
+        {
+            SaveOrSkipWindowSize(rectPersisted);
         }
+
+        subclass?.Dispose();
+        windowNonRudeHWND?.Dispose();
+        window.UninitializeController();
     }
 
     private bool IsNotifyIconVisible()

src/Snap.Hutao/Snap.Hutao/Extension/AppNotificationBuilderExtension.cs

@@ -0,0 +1,20 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Windows.AppNotifications;
+using Microsoft.Windows.AppNotifications.Builder;
+
+namespace Snap.Hutao.Extension;
+
+internal static class AppNotificationBuilderExtension
+{
+    /// <summary>
+    /// Build and show the notification
+    /// </summary>
+    /// <param name="builder">this</param>
+    /// <param name="manager">Defaults to <see cref="AppNotificationManager.Default"/></param>
+    public static void Show(this AppNotificationBuilder builder, AppNotificationManager? manager = default)
+    {
+        (manager ?? AppNotificationManager.Default).Show(builder.BuildNotification());
+    }
+}

src/Snap.Hutao/Snap.Hutao/Extension/EnumerableExtension.List.cs

@@ -199,6 +199,13 @@ internal static partial class EnumerableExtension
         return list;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static List<TSource> SortBy<TSource, TKey>(this List<TSource> list, Func<TSource, TKey> keySelector, Comparison<TKey> comparison)
+    {
+        list.Sort((left, right) => comparison(keySelector(left), keySelector(right)));
+        return list;
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveOptimization)]
     public static List<TSource> SortByDescending<TSource, TKey>(this List<TSource> list, Func<TSource, TKey> keySelector)
         where TKey : IComparable
@@ -213,4 +220,11 @@ internal static partial class EnumerableExtension
         list.Sort((left, right) => comparer.Compare(keySelector(right), keySelector(left)));
         return list;
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static List<TSource> SortByDescending<TSource, TKey>(this List<TSource> list, Func<TSource, TKey> keySelector, Comparison<TKey> comparison)
+    {
+        list.Sort((left, right) => comparison(keySelector(right), keySelector(left)));
+        return list;
+    }
 }

src/Snap.Hutao/Snap.Hutao/Factory/ContentDialog/ContentDialogFactory.cs

@@ -4,6 +4,7 @@
 using Microsoft.UI.Xaml.Controls;
 using Snap.Hutao.Core.LifeCycle;
 using Snap.Hutao.Service;
+using System.Collections.Concurrent;
 
 namespace Snap.Hutao.Factory.ContentDialog;
 
@@ -18,10 +19,27 @@ internal sealed partial class ContentDialogFactory : IContentDialogFactory
     private readonly ITaskContext taskContext;
     private readonly AppOptions appOptions;
 
+    private readonly ConcurrentQueue<Func<Task>> dialogQueue = [];
+    private bool isDialogShowing;
+
+    public bool IsDialogShowing
+    {
+        get
+        {
+            if (currentWindowReference.Window is not { } window)
+            {
+                return false;
+            }
+
+            return isDialogShowing;
+        }
+    }
+
     /// <inheritdoc/>
     public async ValueTask<ContentDialogResult> CreateForConfirmAsync(string title, string content)
     {
         await taskContext.SwitchToMainThreadAsync();
+
         Microsoft.UI.Xaml.Controls.ContentDialog dialog = new()
         {
             XamlRoot = currentWindowReference.GetXamlRoot(),
@@ -39,6 +57,7 @@ internal sealed partial class ContentDialogFactory : IContentDialogFactory
     public async ValueTask<ContentDialogResult> CreateForConfirmCancelAsync(string title, string content, ContentDialogButton defaultButton = ContentDialogButton.Close)
     {
         await taskContext.SwitchToMainThreadAsync();
+
         Microsoft.UI.Xaml.Controls.ContentDialog dialog = new()
         {
             XamlRoot = currentWindowReference.GetXamlRoot(),
@@ -57,6 +76,7 @@ internal sealed partial class ContentDialogFactory : IContentDialogFactory
     public async ValueTask<Microsoft.UI.Xaml.Controls.ContentDialog> CreateForIndeterminateProgressAsync(string title)
     {
         await taskContext.SwitchToMainThreadAsync();
+
         Microsoft.UI.Xaml.Controls.ContentDialog dialog = new()
         {
             XamlRoot = currentWindowReference.GetXamlRoot(),
@@ -72,9 +92,11 @@ internal sealed partial class ContentDialogFactory : IContentDialogFactory
         where TContentDialog : Microsoft.UI.Xaml.Controls.ContentDialog
     {
         await taskContext.SwitchToMainThreadAsync();
+
         TContentDialog contentDialog = serviceProvider.CreateInstance<TContentDialog>(parameters);
         contentDialog.XamlRoot = currentWindowReference.GetXamlRoot();
         contentDialog.RequestedTheme = appOptions.ElementTheme;
+
         return contentDialog;
     }
 
@@ -84,6 +106,51 @@ internal sealed partial class ContentDialogFactory : IContentDialogFactory
         TContentDialog contentDialog = serviceProvider.CreateInstance<TContentDialog>(parameters);
         contentDialog.XamlRoot = currentWindowReference.GetXamlRoot();
         contentDialog.RequestedTheme = appOptions.ElementTheme;
+
         return contentDialog;
     }
+
+    [SuppressMessage("", "SH003")]
+    public Task<ContentDialogResult> EnqueueAndShowAsync(Microsoft.UI.Xaml.Controls.ContentDialog contentDialog)
+    {
+        TaskCompletionSource<ContentDialogResult> dialogShowCompletionSource = new();
+
+        dialogQueue.Enqueue(async () =>
+        {
+            try
+            {
+                ContentDialogResult result = await contentDialog.ShowAsync();
+                dialogShowCompletionSource.SetResult(result);
+            }
+            catch (Exception ex)
+            {
+                dialogShowCompletionSource.SetException(ex);
+            }
+            finally
+            {
+                ShowNextDialog().SafeForget();
+            }
+        });
+
+        if (!isDialogShowing)
+        {
+            ShowNextDialog();
+        }
+
+        return dialogShowCompletionSource.Task;
+
+        Task ShowNextDialog()
+        {
+            if (dialogQueue.TryDequeue(out Func<Task>? showNextDialogAsync))
+            {
+                isDialogShowing = true;
+                return showNextDialogAsync();
+            }
+            else
+            {
+                isDialogShowing = false;
+                return Task.CompletedTask;
+            }
+        }
+    }
 }

src/Snap.Hutao/Snap.Hutao/Factory/ContentDialog/IContentDialogFactory.cs

@@ -11,6 +11,8 @@ namespace Snap.Hutao.Factory.ContentDialog;
 [HighQuality]
 internal interface IContentDialogFactory
 {
+    bool IsDialogShowing { get; }
+
     /// <summary>
     /// 异步确认
     /// </summary>
@@ -40,4 +42,6 @@ internal interface IContentDialogFactory
 
     ValueTask<TContentDialog> CreateInstanceAsync<TContentDialog>(params object[] parameters)
         where TContentDialog : Microsoft.UI.Xaml.Controls.ContentDialog;
+
+    Task<ContentDialogResult> EnqueueAndShowAsync(Microsoft.UI.Xaml.Controls.ContentDialog contentDialog);
 }

src/Snap.Hutao/Snap.Hutao/LaunchGameWindow.xaml.cs

@@ -13,7 +13,7 @@ using Windows.Graphics;
 namespace Snap.Hutao;
 
 [HighQuality]
-[Injection(InjectAs.Singleton)]
+[Injection(InjectAs.Transient)]
 internal sealed partial class LaunchGameWindow : Window,
     IDisposable,
     IXamlWindowExtendContentIntoTitleBar,

src/Snap.Hutao/Snap.Hutao/MainWindow.xaml.cs

@@ -14,7 +14,7 @@ namespace Snap.Hutao;
 /// 主窗体
 /// </summary>
 [HighQuality]
-[Injection(InjectAs.Singleton)]
+[Injection(InjectAs.Transient)]
 internal sealed partial class MainWindow : Window,
     IXamlWindowExtendContentIntoTitleBar,
     IXamlWindowRectPersisted,

src/Snap.Hutao/Snap.Hutao/Migrations/20240616104646_UidProfilePicture.Designer.cs

@@ -0,0 +1,654 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Snap.Hutao.Model.Entity.Database;
+
+#nullable disable
+
+namespace Snap.Hutao.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20240616104646_UidProfilePicture")]
+    partial class UidProfilePicture
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.6");
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.Achievement", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ArchiveId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("Current")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Time")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("ArchiveId");
+
+                    b.ToTable("achievements");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.AchievementArchive", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsSelected")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("achievement_archives");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.AvatarInfo", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CalculatorRefreshTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("GameRecordRefreshTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Info")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ShowcaseRefreshTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("avatar_infos");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateEntry", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("cultivate_entries");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateEntryLevelInformation", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("AvatarLevelFrom")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("AvatarLevelTo")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("EntryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("SkillALevelFrom")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("SkillALevelTo")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("SkillELevelFrom")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("SkillELevelTo")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("SkillQLevelFrom")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("SkillQLevelTo")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("WeaponLevelFrom")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("WeaponLevelTo")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("EntryId")
+                        .IsUnique();
+
+                    b.ToTable("cultivate_entry_level_informations");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateItem", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("EntryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsFinished")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("ItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("EntryId");
+
+                    b.ToTable("cultivate_items");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateProject", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AttachedUid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsSelected")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("cultivate_projects");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.DailyNoteEntry", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DailyNote")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DailyTaskNotify")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DailyTaskNotifySuppressed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ExpeditionNotify")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ExpeditionNotifySuppressed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("HomeCoinNotifySuppressed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("HomeCoinNotifyThreshold")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("RefreshTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ResinNotifySuppressed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ResinNotifyThreshold")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("TransformerNotify")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("TransformerNotifySuppressed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("daily_notes");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.GachaArchive", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsSelected")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("gacha_archives");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.GachaItem", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ArchiveId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("GachaType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("ItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("QueryType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Time")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("ArchiveId");
+
+                    b.ToTable("gacha_items");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.GameAccount", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AttachUid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MihoyoSDK")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("game_accounts");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.InventoryItem", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("ItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("inventory_items");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.InventoryReliquary", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppendPropIdList")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MainPropId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("inventory_reliquaries");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.InventoryWeapon", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PromoteLevel")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("InnerId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("inventory_weapons");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.ObjectCacheEntry", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpireTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("object_cache");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.SettingEntry", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("settings");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.SpiralAbyssEntry", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("ScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SpiralAbyss")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("spiral_abysses");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.UidProfilePicture", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("AvatarId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("CostumeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("ProfilePictureId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("RefreshTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("uid_profile_pictures");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.User", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Aid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CookieToken")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CookieTokenLastUpdateTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Fingerprint")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("FingerprintLastUpdateTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsOversea")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsSelected")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Ltoken");
+
+                    b.Property<string>("Mid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredUid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Stoken");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("users");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.Achievement", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.AchievementArchive", "Archive")
+                        .WithMany()
+                        .HasForeignKey("ArchiveId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Archive");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateEntry", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.CultivateProject", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateEntryLevelInformation", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.CultivateEntry", "Entry")
+                        .WithOne("LevelInformation")
+                        .HasForeignKey("Snap.Hutao.Model.Entity.CultivateEntryLevelInformation", "EntryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Entry");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateItem", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.CultivateEntry", "Entry")
+                        .WithMany()
+                        .HasForeignKey("EntryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Entry");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.DailyNoteEntry", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.GachaItem", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.GachaArchive", "Archive")
+                        .WithMany()
+                        .HasForeignKey("ArchiveId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Archive");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.InventoryItem", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.CultivateProject", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.InventoryReliquary", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.CultivateProject", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.InventoryWeapon", b =>
+                {
+                    b.HasOne("Snap.Hutao.Model.Entity.CultivateProject", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.CultivateEntry", b =>
+                {
+                    b.Navigation("LevelInformation");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Migrations/20240616104646_UidProfilePicture.cs

@@ -0,0 +1,39 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Snap.Hutao.Migrations
+{
+    /// <inheritdoc />
+    public partial class UidProfilePicture : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "uid_profile_pictures",
+                columns: table => new
+                {
+                    InnerId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Uid = table.Column<string>(type: "TEXT", nullable: false),
+                    ProfilePictureId = table.Column<uint>(type: "INTEGER", nullable: false),
+                    AvatarId = table.Column<uint>(type: "INTEGER", nullable: false),
+                    CostumeId = table.Column<uint>(type: "INTEGER", nullable: false),
+                    RefreshTime = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_uid_profile_pictures", x => x.InnerId);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "uid_profile_pictures");
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Migrations/AppDbContextModelSnapshot.cs

@@ -15,7 +15,7 @@ namespace Snap.Hutao.Migrations
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "8.0.2");
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.6");
 
             modelBuilder.Entity("Snap.Hutao.Model.Entity.Achievement", b =>
                 {
@@ -466,6 +466,33 @@ namespace Snap.Hutao.Migrations
                     b.ToTable("spiral_abysses");
                 });
 
+            modelBuilder.Entity("Snap.Hutao.Model.Entity.UidProfilePicture", b =>
+                {
+                    b.Property<Guid>("InnerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("AvatarId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("CostumeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("ProfilePictureId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("RefreshTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InnerId");
+
+                    b.ToTable("uid_profile_pictures");
+                });
+
             modelBuilder.Entity("Snap.Hutao.Model.Entity.User", b =>
                 {
                     b.Property<Guid>("InnerId")

src/Snap.Hutao/Snap.Hutao/Model/Entity/Database/AppDbContext.cs

@@ -65,6 +65,8 @@ internal sealed class AppDbContext : DbContext
 
     public DbSet<SpiralAbyssEntry> SpiralAbysses { get; set; } = default!;
 
+    public DbSet<UidProfilePicture> UidProfilePictures { get; set; } = default!;
+
     public static AppDbContext Create(IServiceProvider serviceProvider, string sqlConnectionString)
     {
         DbContextOptions<AppDbContext> options = new DbContextOptionsBuilder<AppDbContext>()

src/Snap.Hutao/Snap.Hutao/Model/Entity/InventoryItem.cs

@@ -12,7 +12,8 @@ namespace Snap.Hutao.Model.Entity;
 /// </summary>
 [HighQuality]
 [Table("inventory_items")]
-internal sealed class InventoryItem : IDbMappingForeignKeyFrom<InventoryItem, uint>
+internal sealed class InventoryItem : IDbMappingForeignKeyFrom<InventoryItem, uint>,
+    IDbMappingForeignKeyFrom<InventoryItem, uint, uint>
 {
     /// <summary>
     /// 内部Id
@@ -56,4 +57,21 @@ internal sealed class InventoryItem : IDbMappingForeignKeyFrom<InventoryItem, ui
             ItemId = itemId,
         };
     }
+
+    /// <summary>
+    /// 构造一个新的个数不为0的物品
+    /// </summary>
+    /// <param name="projectId">项目Id</param>
+    /// <param name="itemId">物品Id</param>
+    /// <param name="count">物品个数</param>
+    /// <returns>新的个数不为0的物品</returns>
+    public static InventoryItem From(in Guid projectId, in uint itemId, in uint count)
+    {
+        return new()
+        {
+            ProjectId = projectId,
+            ItemId = itemId,
+            Count = count,
+        };
+    }
 }

src/Snap.Hutao/Snap.Hutao/Model/Entity/UidProfilePicture.cs

@@ -0,0 +1,41 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Core.Abstraction;
+using Snap.Hutao.Web.Enka.Model;
+using Snap.Hutao.Web.Hoyolab;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Snap.Hutao.Model.Entity;
+
+[Table("uid_profile_pictures")]
+internal sealed class UidProfilePicture : IMappingFrom<UidProfilePicture, PlayerUid, ProfilePicture>
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public Guid InnerId { get; set; }
+
+    public string Uid { get; set; } = default!;
+
+    public uint ProfilePictureId { get; set; }
+
+    public uint AvatarId { get; set; }
+
+    public uint CostumeId { get; set; }
+
+    public DateTimeOffset RefreshTime { get; set; }
+
+    [SuppressMessage("", "SH002")]
+    public static UidProfilePicture From(PlayerUid uid, ProfilePicture profilePicture)
+    {
+        return new()
+        {
+            Uid = uid.ToString(),
+            ProfilePictureId = profilePicture.Id,
+            AvatarId = profilePicture.AvatarId,
+            CostumeId = profilePicture.CostumeId,
+            RefreshTime = DateTimeOffset.Now,
+        };
+    }
+}

src/Snap.Hutao/Snap.Hutao/Model/InterChange/GachaLog/UIGFItem.cs

@@ -13,7 +13,7 @@ namespace Snap.Hutao.Model.InterChange.GachaLog;
 /// UIGF物品
 /// </summary>
 [HighQuality]
-internal sealed class UIGFItem : GachaLogItem, IMappingFrom<UIGFItem, GachaItem, INameQuality>
+internal sealed class UIGFItem : GachaLogItem, IMappingFrom<UIGFItem, GachaItem, INameQualityAccess>
 {
     /// <summary>
     /// 额外祈愿映射
@@ -22,7 +22,7 @@ internal sealed class UIGFItem : GachaLogItem, IMappingFrom<UIGFItem, GachaItem,
     [JsonEnum(JsonSerializeType.NumberString)]
     public GachaType UIGFGachaType { get; set; } = default!;
 
-    public static UIGFItem From(GachaItem item, INameQuality nameQuality)
+    public static UIGFItem From(GachaItem item, INameQualityAccess nameQuality)
     {
         return new()
         {

src/Snap.Hutao/Snap.Hutao/Model/Intrinsic/ProfilePictureUnlockType.cs

@@ -0,0 +1,13 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Model.Intrinsic;
+
+internal enum ProfilePictureUnlockType
+{
+    None,
+    Item,
+    Avatar,
+    Costume,
+    ParentQuest,
+}

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Abstraction/ICultivationItemsAccess.cs

@@ -0,0 +1,13 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Primitive;
+
+namespace Snap.Hutao.Model.Metadata.Abstraction;
+
+internal interface ICultivationItemsAccess
+{
+    string Name { get; }
+
+    List<MaterialId> CultivationItems { get; }
+}

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Abstraction/IItemConvertible.cs

@@ -3,7 +3,7 @@
 
 namespace Snap.Hutao.Model.Metadata.Abstraction;
 
-internal interface IItemSource
+internal interface IItemConvertible
 {
     Model.Item ToItem();
 }

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Abstraction/INameQualityAccess.cs

@@ -9,7 +9,7 @@ namespace Snap.Hutao.Model.Metadata.Abstraction;
 /// 物品与星级
 /// </summary>
 [HighQuality]
-internal interface INameQuality
+internal interface INameQualityAccess
 {
     /// <summary>
     /// 名称

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Abstraction/IStatisticsItemConvertible.cs

@@ -9,7 +9,7 @@ namespace Snap.Hutao.Model.Metadata.Abstraction;
 /// 指示该类为统计物品的源
 /// </summary>
 [HighQuality]
-internal interface IStatisticsItemSource
+internal interface IStatisticsItemConvertible
 {
     /// <summary>
     /// 转换到统计物品

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Abstraction/ISummaryItemConvertible.cs

@@ -10,19 +10,9 @@ namespace Snap.Hutao.Model.Metadata.Abstraction;
 /// 指示该类为简述统计物品的源
 /// </summary>
 [HighQuality]
-internal interface ISummaryItemSource
+internal interface ISummaryItemConvertible
 {
-    /// <summary>
-    /// 星级
-    /// </summary>
     QualityType Quality { get; }
 
-    /// <summary>
-    /// 转换到简述统计物品
-    /// </summary>
-    /// <param name="lastPull">距上个五星</param>
-    /// <param name="time">时间</param>
-    /// <param name="isUp">是否为Up物品</param>
-    /// <returns>简述统计物品</returns>
     SummaryItem ToSummaryItem(int lastPull, in DateTimeOffset time, bool isUp);
 }

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Avatar/Avatar.Implementation.cs

@@ -1,99 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Snap.Hutao.Model.Calculable;
-using Snap.Hutao.Model.Metadata.Abstraction;
-using Snap.Hutao.Model.Metadata.Converter;
-using Snap.Hutao.Model.Metadata.Item;
-using Snap.Hutao.ViewModel.Complex;
-using Snap.Hutao.ViewModel.GachaLog;
-using Snap.Hutao.ViewModel.Wiki;
-
-namespace Snap.Hutao.Model.Metadata.Avatar;
-
-/// <summary>
-/// 角色的接口实现部分
-/// </summary>
-internal partial class Avatar : IStatisticsItemSource, ISummaryItemSource, IItemSource, INameQuality, ICalculableSource<ICalculableAvatar>
-{
-    /// <summary>
-    /// [非元数据] 搭配数据
-    /// TODO:Add View suffix.
-    /// </summary>
-    [JsonIgnore]
-    public AvatarCollocationView? Collocation { get; set; }
-
-    /// <summary>
-    /// [非元数据] 烹饪奖励
-    /// </summary>
-    [JsonIgnore]
-    public CookBonusView? CookBonusView { get; set; }
-
-    /// <summary>
-    /// [非元数据] 养成物品视图
-    /// </summary>
-    [JsonIgnore]
-    public List<Material>? CultivationItemsView { get; set; }
-
-    /// <summary>
-    /// 最大等级
-    /// </summary>
-    [SuppressMessage("", "CA1822")]
-    public uint MaxLevel { get => GetMaxLevel(); }
-
-    public static uint GetMaxLevel()
-    {
-        return 90U;
-    }
-
-    /// <inheritdoc/>
-    public ICalculableAvatar ToCalculable()
-    {
-        return CalculableAvatar.From(this);
-    }
-
-    /// <summary>
-    /// 转换为基础物品
-    /// </summary>
-    /// <returns>基础物品</returns>
-    public Model.Item ToItem()
-    {
-        return new()
-        {
-            Name = Name,
-            Icon = AvatarIconConverter.IconNameToUri(Icon),
-            Badge = ElementNameIconConverter.ElementNameToIconUri(FetterInfo.VisionBefore),
-            Quality = Quality,
-        };
-    }
-
-    /// <inheritdoc/>
-    public StatisticsItem ToStatisticsItem(int count)
-    {
-        return new()
-        {
-            Name = Name,
-            Icon = AvatarIconConverter.IconNameToUri(Icon),
-            Badge = ElementNameIconConverter.ElementNameToIconUri(FetterInfo.VisionBefore),
-            Quality = Quality,
-
-            Count = count,
-        };
-    }
-
-    /// <inheritdoc/>
-    public SummaryItem ToSummaryItem(int lastPull, in DateTimeOffset time, bool isUp)
-    {
-        return new()
-        {
-            Name = Name,
-            Icon = AvatarIconConverter.IconNameToUri(Icon),
-            Badge = ElementNameIconConverter.ElementNameToIconUri(FetterInfo.VisionBefore),
-            Quality = Quality,
-
-            Time = time,
-            LastPull = lastPull,
-            IsUp = isUp,
-        };
-    }
-}

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Avatar/Avatar.cs

@@ -1,99 +1,118 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Model.Calculable;
 using Snap.Hutao.Model.Intrinsic;
+using Snap.Hutao.Model.Metadata.Abstraction;
+using Snap.Hutao.Model.Metadata.Converter;
+using Snap.Hutao.Model.Metadata.Item;
 using Snap.Hutao.Model.Primitive;
+using Snap.Hutao.ViewModel.Complex;
+using Snap.Hutao.ViewModel.GachaLog;
+using Snap.Hutao.ViewModel.Wiki;
 
 namespace Snap.Hutao.Model.Metadata.Avatar;
 
-/// <summary>
-/// 角色
-/// </summary>
 [HighQuality]
-internal partial class Avatar
+internal partial class Avatar : INameQualityAccess,
+    IStatisticsItemConvertible,
+    ISummaryItemConvertible,
+    IItemConvertible,
+    ICalculableSource<ICalculableAvatar>,
+    ICultivationItemsAccess
 {
-    /// <summary>
-    /// Id
-    /// </summary>
     public AvatarId Id { get; set; }
 
-    /// <summary>
-    /// 突破提升 Id 外键
-    /// </summary>
     public PromoteId PromoteId { get; set; }
 
-    /// <summary>
-    /// 排序号
-    /// </summary>
     public uint Sort { get; set; }
 
-    /// <summary>
-    /// 体型
-    /// </summary>
     public BodyType Body { get; set; } = default!;
 
-    /// <summary>
-    /// 正面图标
-    /// </summary>
     public string Icon { get; set; } = default!;
 
-    /// <summary>
-    /// 侧面图标
-    /// </summary>
     public string SideIcon { get; set; } = default!;
 
-    /// <summary>
-    /// 名称
-    /// </summary>
     public string Name { get; set; } = default!;
 
-    /// <summary>
-    /// 描述
-    /// </summary>
     public string Description { get; set; } = default!;
 
-    /// <summary>
-    /// 角色加入游戏时间
-    /// </summary>
     public DateTimeOffset BeginTime { get; set; }
 
-    /// <summary>
-    /// 星级
-    /// </summary>
     public QualityType Quality { get; set; }
 
-    /// <summary>
-    /// 武器类型
-    /// </summary>
     public WeaponType Weapon { get; set; }
 
-    /// <summary>
-    /// 基础数值
-    /// </summary>
     public AvatarBaseValue BaseValue { get; set; } = default!;
 
-    /// <summary>
-    /// 生长曲线
-    /// </summary>
     public List<TypeValue<FightProperty, GrowCurveType>> GrowCurves { get; set; } = default!;
 
-    /// <summary>
-    /// 技能
-    /// </summary>
     public SkillDepot SkillDepot { get; set; } = default!;
 
-    /// <summary>
-    /// 好感信息/基本信息
-    /// </summary>
     public FetterInfo FetterInfo { get; set; } = default!;
 
-    /// <summary>
-    /// 皮肤
-    /// </summary>
     public List<Costume> Costumes { get; set; } = default!;
 
-    /// <summary>
-    /// 养成物品
-    /// </summary>
     public List<MaterialId> CultivationItems { get; set; } = default!;
+
+    [JsonIgnore]
+    public AvatarCollocationView? CollocationView { get; set; }
+
+    [JsonIgnore]
+    public CookBonusView? CookBonusView { get; set; }
+
+    [JsonIgnore]
+    public List<Material>? CultivationItemsView { get; set; }
+
+    [SuppressMessage("", "CA1822")]
+    public uint MaxLevel { get => GetMaxLevel(); }
+
+    public static uint GetMaxLevel()
+    {
+        return 90U;
+    }
+
+    public ICalculableAvatar ToCalculable()
+    {
+        return CalculableAvatar.From(this);
+    }
+
+    public Model.Item ToItem()
+    {
+        return new()
+        {
+            Name = Name,
+            Icon = AvatarIconConverter.IconNameToUri(Icon),
+            Badge = ElementNameIconConverter.ElementNameToIconUri(FetterInfo.VisionBefore),
+            Quality = Quality,
+        };
+    }
+
+    public StatisticsItem ToStatisticsItem(int count)
+    {
+        return new()
+        {
+            Name = Name,
+            Icon = AvatarIconConverter.IconNameToUri(Icon),
+            Badge = ElementNameIconConverter.ElementNameToIconUri(FetterInfo.VisionBefore),
+            Quality = Quality,
+
+            Count = count,
+        };
+    }
+
+    public SummaryItem ToSummaryItem(int lastPull, in DateTimeOffset time, bool isUp)
+    {
+        return new()
+        {
+            Name = Name,
+            Icon = AvatarIconConverter.IconNameToUri(Icon),
+            Badge = ElementNameIconConverter.ElementNameToIconUri(FetterInfo.VisionBefore),
+            Quality = Quality,
+
+            Time = time,
+            LastPull = lastPull,
+            IsUp = isUp,
+        };
+    }
 }

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Avatar/ProfilePicture.cs

@@ -1,6 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Model.Intrinsic;
 using Snap.Hutao.Model.Primitive;
 
 namespace Snap.Hutao.Model.Metadata.Avatar;
@@ -12,4 +13,17 @@ internal sealed class ProfilePicture
     public string Icon { get; set; } = default!;
 
     public string Name { get; set; } = default!;
-}
+
+    public ProfilePictureUnlockType UnlockType { get; set; }
+
+    /// <summary>
+    /// <see cref="ProfilePictureUnlockType.Item"/> -> <see cref="MaterialId"/>
+    /// <br/>
+    /// <see cref="ProfilePictureUnlockType.Avatar"/> -> <see cref="AvatarId"/>
+    /// <br/>
+    /// <see cref="ProfilePictureUnlockType.Costume"/> -> <see cref="CostumeId"/>
+    /// <br/>
+    /// <see cref="ProfilePictureUnlockType.ParentQuest"/> -> <see cref="QuestId"/>
+    /// </summary>
+    public uint UnlockParameter { get; set; }
+}

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Converter/AvatarIconCircleConverter.cs

@@ -0,0 +1,29 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Control;
+
+namespace Snap.Hutao.Model.Metadata.Converter;
+
+/// <summary>
+/// 玩家头像转换器
+/// </summary>
+[HighQuality]
+internal sealed class AvatarIconCircleConverter : ValueConverter<string, Uri>
+{
+    /// <summary>
+    /// 名称转Uri
+    /// </summary>
+    /// <param name="name">名称</param>
+    /// <returns>链接</returns>
+    public static Uri IconNameToUri(string name)
+    {
+        return Web.HutaoEndpoints.StaticRaw("AvatarIconCircle", $"{name}.png").ToUri();
+    }
+
+    /// <inheritdoc/>
+    public override Uri Convert(string from)
+    {
+        return IconNameToUri(from);
+    }
+}

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Weapon/Weapon.Implementation.cs

@@ -1,107 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Snap.Hutao.Model.Calculable;
-using Snap.Hutao.Model.Intrinsic;
-using Snap.Hutao.Model.Metadata.Abstraction;
-using Snap.Hutao.Model.Metadata.Converter;
-using Snap.Hutao.Model.Metadata.Item;
-using Snap.Hutao.ViewModel.Complex;
-using Snap.Hutao.ViewModel.GachaLog;
-
-namespace Snap.Hutao.Model.Metadata.Weapon;
-
-/// <summary>
-/// 武器的接口实现
-/// </summary>
-internal sealed partial class Weapon : IStatisticsItemSource, ISummaryItemSource, IItemSource, INameQuality, ICalculableSource<ICalculableWeapon>
-{
-    /// <summary>
-    /// [非元数据] 搭配数据
-    /// TODO:Add View suffix.
-    /// </summary>
-    [JsonIgnore]
-    public WeaponCollocationView? Collocation { get; set; }
-
-    /// <summary>
-    /// [非元数据] 养成物品视图
-    /// </summary>
-    [JsonIgnore]
-    public List<Material>? CultivationItemsView { get; set; }
-
-    /// <inheritdoc cref="INameQuality.Quality" />
-    [JsonIgnore]
-    public QualityType Quality
-    {
-        get => RankLevel;
-    }
-
-    /// <summary>
-    /// 最大等级
-    /// </summary>
-    internal uint MaxLevel { get => GetMaxLevelByQuality(Quality); }
-
-    public static uint GetMaxLevelByQuality(QualityType quality)
-    {
-        return quality >= QualityType.QUALITY_BLUE ? 90U : 70U;
-    }
-
-    /// <inheritdoc/>
-    public ICalculableWeapon ToCalculable()
-    {
-        return CalculableWeapon.From(this);
-    }
-
-    /// <summary>
-    /// 转换为基础物品
-    /// </summary>
-    /// <returns>基础物品</returns>
-    public Model.Item ToItem()
-    {
-        return new()
-        {
-            Name = Name,
-            Icon = EquipIconConverter.IconNameToUri(Icon),
-            Badge = WeaponTypeIconConverter.WeaponTypeToIconUri(WeaponType),
-            Quality = RankLevel,
-        };
-    }
-
-    /// <summary>
-    /// 转换到统计物品
-    /// </summary>
-    /// <param name="count">个数</param>
-    /// <returns>统计物品</returns>
-    public StatisticsItem ToStatisticsItem(int count)
-    {
-        return new()
-        {
-            Name = Name,
-            Icon = EquipIconConverter.IconNameToUri(Icon),
-            Badge = WeaponTypeIconConverter.WeaponTypeToIconUri(WeaponType),
-            Quality = RankLevel,
-            Count = count,
-        };
-    }
-
-    /// <summary>
-    /// 转换到简述统计物品
-    /// </summary>
-    /// <param name="lastPull">距上个五星</param>
-    /// <param name="time">时间</param>
-    /// <param name="isUp">是否为Up物品</param>
-    /// <returns>简述统计物品</returns>
-    public SummaryItem ToSummaryItem(int lastPull, in DateTimeOffset time, bool isUp)
-    {
-        return new()
-        {
-            Name = Name,
-            Icon = EquipIconConverter.IconNameToUri(Icon),
-            Badge = WeaponTypeIconConverter.WeaponTypeToIconUri(WeaponType),
-            Time = time,
-            Quality = RankLevel,
-            LastPull = lastPull,
-            IsUp = isUp,
-        };
-    }
-}

src/Snap.Hutao/Snap.Hutao/Model/Metadata/Weapon/Weapon.cs

@@ -1,69 +1,107 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Model.Calculable;
 using Snap.Hutao.Model.Intrinsic;
+using Snap.Hutao.Model.Metadata.Abstraction;
+using Snap.Hutao.Model.Metadata.Converter;
+using Snap.Hutao.Model.Metadata.Item;
 using Snap.Hutao.Model.Primitive;
+using Snap.Hutao.ViewModel.Complex;
+using Snap.Hutao.ViewModel.GachaLog;
 
 namespace Snap.Hutao.Model.Metadata.Weapon;
 
-/// <summary>
-/// 武器
-/// </summary>
 [HighQuality]
-internal sealed partial class Weapon
+internal sealed partial class Weapon : INameQualityAccess,
+    IStatisticsItemConvertible,
+    ISummaryItemConvertible,
+    IItemConvertible,
+    ICalculableSource<ICalculableWeapon>,
+    ICultivationItemsAccess
 {
-    /// <summary>
-    /// Id
-    /// </summary>
     public WeaponId Id { get; set; }
 
-    /// <summary>
-    /// 突破 Id
-    /// </summary>
     public PromoteId PromoteId { get; set; }
 
-    /// <summary>
-    /// 武器类型
-    /// </summary>
+    public uint Sort { get; set; }
+
     public WeaponType WeaponType { get; set; }
 
-    /// <summary>
-    /// 等级
-    /// </summary>
     public QualityType RankLevel { get; set; }
 
-    /// <summary>
-    /// 名称
-    /// </summary>
     public string Name { get; set; } = default!;
 
-    /// <summary>
-    /// 描述
-    /// </summary>
     public string Description { get; set; } = default!;
 
-    /// <summary>
-    /// 图标
-    /// </summary>
     public string Icon { get; set; } = default!;
 
-    /// <summary>
-    /// 觉醒图标
-    /// </summary>
     public string AwakenIcon { get; set; } = default!;
 
-    /// <summary>
-    /// 生长曲线
-    /// </summary>
     public List<WeaponTypeValue> GrowCurves { get; set; } = default!;
 
-    /// <summary>
-    /// 被动信息, 无被动的武器为 <see langword="null"/>
-    /// </summary>
     public NameDescriptions? Affix { get; set; } = default!;
 
-    /// <summary>
-    /// 养成物品
-    /// </summary>
     public List<MaterialId> CultivationItems { get; set; } = default!;
+
+    [JsonIgnore]
+    public WeaponCollocationView? CollocationView { get; set; }
+
+    [JsonIgnore]
+    public List<Material>? CultivationItemsView { get; set; }
+
+    [JsonIgnore]
+    public QualityType Quality
+    {
+        get => RankLevel;
+    }
+
+    internal uint MaxLevel { get => GetMaxLevelByQuality(Quality); }
+
+    public static uint GetMaxLevelByQuality(QualityType quality)
+    {
+        return quality >= QualityType.QUALITY_BLUE ? 90U : 70U;
+    }
+
+    public ICalculableWeapon ToCalculable()
+    {
+        return CalculableWeapon.From(this);
+    }
+
+    public Model.Item ToItem()
+    {
+        return new()
+        {
+            Name = Name,
+            Icon = EquipIconConverter.IconNameToUri(Icon),
+            Badge = WeaponTypeIconConverter.WeaponTypeToIconUri(WeaponType),
+            Quality = RankLevel,
+        };
+    }
+
+    public StatisticsItem ToStatisticsItem(int count)
+    {
+        return new()
+        {
+            Name = Name,
+            Icon = EquipIconConverter.IconNameToUri(Icon),
+            Badge = WeaponTypeIconConverter.WeaponTypeToIconUri(WeaponType),
+            Quality = RankLevel,
+            Count = count,
+        };
+    }
+
+    public SummaryItem ToSummaryItem(int lastPull, in DateTimeOffset time, bool isUp)
+    {
+        return new()
+        {
+            Name = Name,
+            Icon = EquipIconConverter.IconNameToUri(Icon),
+            Badge = WeaponTypeIconConverter.WeaponTypeToIconUri(WeaponType),
+            Time = time,
+            Quality = RankLevel,
+            LastPull = lastPull,
+            IsUp = isUp,
+        };
+    }
 }

src/Snap.Hutao/Snap.Hutao/Package.appxmanifest

@@ -50,7 +50,7 @@
         </desktop:Extension>
         <com:Extension Category="windows.comServer">
           <com:ComServer>
-            <com:ExeServer Executable="Snap.Hutao.exe" Arguments="-ToastActivated" DisplayName="Snap Hutao Toast Activator">
+            <com:ExeServer Executable="Snap.Hutao.exe" Arguments="----AppNotificationActivated:" DisplayName="Snap Hutao Toast Activator">
               <com:Class Id="5760EC4D-F7E8-4666-A965-9886D7DFFE7D" DisplayName="Snap Hutao Toast Activator"/>
             </com:ExeServer>
           </com:ComServer>

src/Snap.Hutao/Snap.Hutao/Package.development.appxmanifest

@@ -50,7 +50,7 @@
         </desktop:Extension>
         <com:Extension Category="windows.comServer">
           <com:ComServer>
-            <com:ExeServer Executable="Snap.Hutao.exe" Arguments="-ToastActivated" DisplayName="Snap Hutao Dev Toast Activator">
+            <com:ExeServer Executable="Snap.Hutao.exe" Arguments="----AppNotificationActivated:" DisplayName="Snap Hutao Toast Activator">
               <com:Class Id="F32B561D-752E-472B-A22C-85824D421E1A" DisplayName="Snap Hutao Dev Toast Activator"/>
             </com:ExeServer>
           </com:ComServer>

src/Snap.Hutao/Snap.Hutao/Resource/Localization/SH.resx

@@ -1568,6 +1568,9 @@
   <data name="ViewModelCultivationProjectInvalidName" xml:space="preserve">
     <value>不能添加名称无效的计划</value>
   </data>
+  <data name="ViewModelCultivationRefreshInventoryProgress" xml:space="preserve">
+    <value>正在同步背包物品</value>
+  </data>
   <data name="ViewModelCultivationRemoveProjectContent" xml:space="preserve">
     <value>此操作不可逆，此计划的养成物品与背包材料将会丢失</value>
   </data>
@@ -1925,6 +1928,9 @@
   <data name="ViewPageCultivationNavigateAction" xml:space="preserve">
     <value>前往</value>
   </data>
+  <data name="ViewPageCultivationRefreshInventory" xml:space="preserve">
+    <value>同步背包物品</value>
+  </data>
   <data name="ViewPageCultivationRemoveEntry" xml:space="preserve">
     <value>删除清单</value>
   </data>
@@ -2589,7 +2595,7 @@
     <value>选择想要获取公告的游戏服务器</value>
   </data>
   <data name="ViewPageSettingHomeAnnouncementRegionHeader" xml:space="preserve">
-    <value>公告所属服务器</value>
+    <value>游戏公告所属服务器</value>
   </data>
   <data name="ViewpageSettingHomeCardDescription" xml:space="preserve">
     <value>管理主页仪表板中的卡片</value>

src/Snap.Hutao/Snap.Hutao/Service/Announcement/AnnouncementService.cs

@@ -20,7 +20,7 @@ namespace Snap.Hutao.Service;
 [Injection(InjectAs.Scoped, typeof(IAnnouncementService))]
 internal sealed partial class AnnouncementService : IAnnouncementService
 {
-    private static readonly string CacheKey = $"{nameof(AnnouncementService)}.Cache.{nameof(AnnouncementWrapper)}";
+    private const string CacheKey = $"{nameof(AnnouncementService)}.Cache.{nameof(AnnouncementWrapper)}";
 
     private readonly IServiceScopeFactory serviceScopeFactory;
     private readonly ITaskContext taskContext;

src/Snap.Hutao/Snap.Hutao/Service/Cultivation/CultivationDbService.cs

@@ -16,16 +16,6 @@ internal sealed partial class CultivationDbService : ICultivationDbService
 
     public IServiceProvider ServiceProvider { get => serviceProvider; }
 
-    public List<InventoryItem> GetInventoryItemListByProjectId(Guid projectId)
-    {
-        return this.List<InventoryItem>(i => i.ProjectId == projectId);
-    }
-
-    public ValueTask<List<InventoryItem>> GetInventoryItemListByProjectIdAsync(Guid projectId, CancellationToken token = default)
-    {
-        return this.ListAsync<InventoryItem>(i => i.ProjectId == projectId, token);
-    }
-
     public ValueTask<List<CultivateEntry>> GetCultivateEntryListByProjectIdAsync(Guid projectId, CancellationToken token = default)
     {
         return this.ListAsync<CultivateEntry>(e => e.ProjectId == projectId, token);

src/Snap.Hutao/Snap.Hutao/Service/Cultivation/CultivationService.cs

@@ -2,15 +2,14 @@
 // Licensed under the MIT license.
 
 using Snap.Hutao.Core.Database;
-using Snap.Hutao.Model;
 using Snap.Hutao.Model.Entity;
 using Snap.Hutao.Model.Entity.Primitive;
-using Snap.Hutao.Model.Metadata.Item;
 using Snap.Hutao.Service.Inventory;
 using Snap.Hutao.Service.Metadata.ContextAbstraction;
 using Snap.Hutao.ViewModel.Cultivation;
 using System.Collections.ObjectModel;
 using CalculateItem = Snap.Hutao.Web.Hoyolab.Takumi.Event.Calculate.Item;
+using ModelItem = Snap.Hutao.Model.Item;
 
 namespace Snap.Hutao.Service.Cultivation;
 
@@ -51,22 +50,6 @@ internal sealed partial class CultivationService : ICultivationService
         }
     }
 
-    /// <inheritdoc/>
-    public List<InventoryItemView> GetInventoryItemViews(CultivateProject cultivateProject, ICultivationMetadataContext context, ICommand saveCommand)
-    {
-        Guid projectId = cultivateProject.InnerId;
-        List<InventoryItem> entities = cultivationDbService.GetInventoryItemListByProjectId(projectId);
-
-        List<InventoryItemView> results = [];
-        foreach (Material meta in context.EnumerateInventoryMaterial())
-        {
-            InventoryItem entity = entities.SingleOrDefault(e => e.ItemId == meta.Id) ?? InventoryItem.From(projectId, meta.Id);
-            results.Add(new(entity, meta, saveCommand));
-        }
-
-        return results;
-    }
-
     /// <inheritdoc/>
     public async ValueTask<ObservableCollection<CultivateEntryView>> GetCultivateEntriesAsync(CultivateProject cultivateProject, ICultivationMetadataContext context)
     {
@@ -86,7 +69,7 @@ internal sealed partial class CultivationService : ICultivationService
                 entryItems.Add(new(cultivateItem, context.GetMaterial(cultivateItem.ItemId)));
             }
 
-            Item item = entry.Type switch
+            ModelItem item = entry.Type switch
             {
                 CultivateType.AvatarAndSkill => context.GetAvatar(entry.Id).ToItem(),
                 CultivateType.Weapon => context.GetWeapon(entry.Id).ToItem(),
@@ -130,7 +113,7 @@ internal sealed partial class CultivationService : ICultivationService
             }
         }
 
-        foreach (InventoryItem inventoryItem in await cultivationDbService.GetInventoryItemListByProjectIdAsync(projectId, token).ConfigureAwait(false))
+        foreach (InventoryItem inventoryItem in await inventoryDbService.GetInventoryItemListByProjectIdAsync(projectId, token).ConfigureAwait(false))
         {
             if (resultItems.SingleOrDefault(i => i.Inner.Id == inventoryItem.ItemId) is { } existedItem)
             {
@@ -147,12 +130,6 @@ internal sealed partial class CultivationService : ICultivationService
         await cultivationDbService.RemoveCultivateEntryByIdAsync(entryId).ConfigureAwait(false);
     }
 
-    /// <inheritdoc/>
-    public void SaveInventoryItem(InventoryItemView item)
-    {
-        inventoryDbService.UpdateInventoryItem(item.Entity);
-    }
-
     /// <inheritdoc/>
     public void SaveCultivateItem(CultivateItemView item)
     {

src/Snap.Hutao/Snap.Hutao/Service/Cultivation/ICultivationDbService.cs

@@ -7,8 +7,7 @@ using System.Collections.ObjectModel;
 
 namespace Snap.Hutao.Service.Cultivation;
 
-internal interface ICultivationDbService : IAppDbService<InventoryItem>,
-    IAppDbService<CultivateEntryLevelInformation>,
+internal interface ICultivationDbService : IAppDbService<CultivateEntryLevelInformation>,
     IAppDbService<CultivateProject>,
     IAppDbService<CultivateEntry>,
     IAppDbService<CultivateItem>
@@ -29,10 +28,6 @@ internal interface ICultivationDbService : IAppDbService<InventoryItem>,
 
     ObservableCollection<CultivateProject> GetCultivateProjectCollection();
 
-    List<InventoryItem> GetInventoryItemListByProjectId(Guid projectId);
-
-    ValueTask<List<InventoryItem>> GetInventoryItemListByProjectIdAsync(Guid projectId, CancellationToken token = default);
-
     ValueTask AddCultivateEntryAsync(CultivateEntry entry, CancellationToken token = default);
 
     ValueTask AddCultivateItemRangeAsync(IEnumerable<CultivateItem> toAdd, CancellationToken token = default);

src/Snap.Hutao/Snap.Hutao/Service/Cultivation/ICultivationService.cs

@@ -27,8 +27,6 @@ internal interface ICultivationService
 
     ValueTask<ObservableCollection<CultivateEntryView>> GetCultivateEntriesAsync(CultivateProject cultivateProject, ICultivationMetadataContext context);
 
-    List<InventoryItemView> GetInventoryItemViews(CultivateProject cultivateProject, ICultivationMetadataContext context, ICommand saveCommand);
-
     ValueTask<ObservableCollection<StatisticsCultivateItem>> GetStatisticsCultivateItemCollectionAsync(
         CultivateProject cultivateProject, ICultivationMetadataContext context, CancellationToken token);
 
@@ -54,12 +52,6 @@ internal interface ICultivationService
     /// <param name="item">养成物品</param>
     void SaveCultivateItem(CultivateItemView item);
 
-    /// <summary>
-    /// 保存单个物品
-    /// </summary>
-    /// <param name="item">物品</param>
-    void SaveInventoryItem(InventoryItemView item);
-
     /// <summary>
     /// 异步尝试添加新的项目
     /// </summary>

src/Snap.Hutao/Snap.Hutao/Service/DailyNote/DailyNoteNotificationOperation.cs

@@ -1,7 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using CommunityToolkit.WinUI.Notifications;
+using Microsoft.Windows.AppNotifications;
 using Snap.Hutao.Core;
 using Snap.Hutao.Core.LifeCycle;
 using Snap.Hutao.Model.Entity;
@@ -20,7 +20,6 @@ namespace Snap.Hutao.Service.DailyNote;
 [Injection(InjectAs.Singleton)]
 internal sealed partial class DailyNoteNotificationOperation
 {
-    private const string ToastHeaderIdArgument = "DAILYNOTE";
     private const string ToastAttributionUnknown = "Unknown";
 
     private readonly ITaskContext taskContext;
@@ -52,57 +51,57 @@ internal sealed partial class DailyNoteNotificationOperation
             ? entry.UserGameRole.ToString()
             : await GetUserUidAsync(entry).ConfigureAwait(false);
 
-        ToastContentBuilder builder = new ToastContentBuilder()
-            .AddHeader(ToastHeaderIdArgument, SH.ServiceDailyNoteNotifierTitle, ToastHeaderIdArgument)
-            .AddAttributionText(attribution)
-            .AddButton(new ToastButton()
-                .SetContent(SH.ServiceDailyNoteNotifierActionLaunchGameButton)
-                .AddArgument(AppActivation.Action, AppActivation.LaunchGame)
-                .AddArgument(AppActivation.Uid, entry.Uid))
-            .AddButton(new ToastButtonDismiss(SH.ServiceDailyNoteNotifierActionLaunchGameDismiss));
-
-        if (options.IsReminderNotification)
-        {
-            builder.SetToastScenario(ToastScenario.Reminder);
-        }
+        string reminder = options.IsReminderNotification ? @"scenario=""reminder""" : string.Empty;
+        string content;
 
         if (notifyInfos.Count > 2)
         {
-            builder.AddText(SH.ServiceDailyNoteNotifierMultiValueReached);
+            string adaptiveSubgroups = string.Join(string.Empty, notifyInfos.Select(info => $"""
+                <subgroup>
+                    <text hint-align="center">{info.AdaptiveHint}</text>
+                    <text hint-style="captionSubtle" hint-align="center">{info.Title}</text>
+                </subgroup>
+            """));
 
-            // Desktop and Mobile started supporting adaptive toasts in API contract 3 (Anniversary Update)
-            if (UniversalApiContract.IsPresent(WindowsVersion.Windows10AnniversaryUpdate))
-            {
-                AdaptiveGroup group = new();
-                foreach (DailyNoteNotifyInfo info in notifyInfos)
-                {
-                    AdaptiveSubgroup subgroup = new()
-                    {
-                        HintWeight = 1,
-                        Children =
-                        {
-                            // new AdaptiveImage() { Source = info.AdaptiveIcon, HintRemoveMargin = true, },
-                            new AdaptiveText() { Text = info.AdaptiveHint, HintAlign = AdaptiveTextAlign.Center,  },
-                            new AdaptiveText() { Text = info.Title, HintAlign = AdaptiveTextAlign.Center, HintStyle = AdaptiveTextStyle.CaptionSubtle, },
-                        },
-                    };
-
-                    group.Children.Add(subgroup);
-                }
-
-                builder.AddVisualChild(group);
-            }
+            content = $"""
+                <text>{SH.ServiceDailyNoteNotifierMultiValueReached}</text>
+                <group>
+                {adaptiveSubgroups}
+                </group>
+                """;
         }
         else
         {
-            foreach (DailyNoteNotifyInfo info in notifyInfos)
-            {
-                builder.AddText(info.Hint);
-            }
+            content = string.Join(string.Empty, notifyInfos.Select(info => $"""
+                <text>{info.Hint}</text>
+            """));
+        }
+
+        string rawXml = $"""
+            <toast {reminder}>
+                <header title="{SH.ServiceDailyNoteNotifierTitle}" id="DAILYNOTE" arguments="DAILYNOTE"/>
+
+                <visual>
+                    <binding template="ToastGeneric">
+                        {content}
+                        <text placement="attribution">{attribution}</text>
+                    </binding>
+                </visual>
+                <actions>
+                    <action activationType="background" content="{SH.ServiceDailyNoteNotifierActionLaunchGameButton}" arguments="{AppActivation.Action}={AppActivation.LaunchGame};{AppActivation.Uid}={entry.Uid}"/>
+                    <action activationType="system" content="{SH.ServiceDailyNoteNotifierActionLaunchGameDismiss}" arguments="dismiss"/>
+                </actions>
+            </toast>
+            """;
+        AppNotification notification = new(rawXml);
+
+        if (options.IsSilentWhenPlayingGame && gameService.IsGameRunning())
+        {
+            notification.SuppressDisplay = true;
         }
 
         await taskContext.SwitchToMainThreadAsync();
-        builder.Show(toast => toast.SuppressPopup = ShouldSuppressPopup(options));
+        AppNotificationManager.Default.Show(notification);
     }
 
     private bool ShouldSuppressPopup(DailyNoteOptions options)

src/Snap.Hutao/Snap.Hutao/Service/DailyNote/DailyNoteOptions.cs

@@ -48,7 +48,7 @@ internal sealed partial class DailyNoteOptions : DbStoreOptions
                     {
                         quartzService.UpdateJobAsync(JobIdentity.DailyNoteGroupName, JobIdentity.DailyNoteRefreshTriggerName, builder =>
                         {
-                            return builder.WithSimpleSchedule(sb => sb.WithIntervalInMinutes(SelectedRefreshTime.Value).RepeatForever());
+                            return builder.WithSimpleSchedule(sb => sb.WithIntervalInSeconds(SelectedRefreshTime.Value).RepeatForever());
                         }).SafeForget();
                     }
                 }

src/Snap.Hutao/Snap.Hutao/Service/GachaLog/Factory/GachaStatisticsExtension.cs

@@ -49,7 +49,7 @@ internal static class GachaStatisticsExtension
     /// <param name="dict">计数器</param>
     /// <returns>统计物品列表</returns>
     public static List<StatisticsItem> ToStatisticsList<TItem>(this Dictionary<TItem, int> dict)
-        where TItem : IStatisticsItemSource
+        where TItem : IStatisticsItemConvertible
     {
         IOrderedEnumerable<StatisticsItem> result = dict
             .Select(kvp => kvp.Key.ToStatisticsItem(kvp.Value))

src/Snap.Hutao/Snap.Hutao/Service/GachaLog/Factory/GachaStatisticsSlimFactory.cs

@@ -27,7 +27,7 @@ internal sealed partial class GachaStatisticsSlimFactory : IGachaStatisticsSlimF
         return CreateCore(context, items, uid);
     }
 
-    private static void Track(INameQuality nameQuality, ref int orangeTracker, ref int purpleTracker)
+    private static void Track(INameQualityAccess nameQuality, ref int orangeTracker, ref int purpleTracker)
     {
         switch (nameQuality.Quality)
         {
@@ -69,7 +69,7 @@ internal sealed partial class GachaStatisticsSlimFactory : IGachaStatisticsSlimF
         // O(n) operation
         foreach (ref readonly GachaItem item in CollectionsMarshal.AsSpan(items))
         {
-            INameQuality nameQuality = context.GetNameQualityByItemId(item.ItemId);
+            INameQualityAccess nameQuality = context.GetNameQualityByItemId(item.ItemId);
             switch (item.QueryType)
             {
                 case GachaType.Standard:

src/Snap.Hutao/Snap.Hutao/Service/GachaLog/Factory/HistoryWishBuilder.cs

@@ -16,11 +16,11 @@ internal sealed class HistoryWishBuilder
 {
     private readonly GachaEvent gachaEvent;
 
-    private readonly Dictionary<IStatisticsItemSource, int> orangeUpCounter = [];
-    private readonly Dictionary<IStatisticsItemSource, int> purpleUpCounter = [];
-    private readonly Dictionary<IStatisticsItemSource, int> orangeCounter = [];
-    private readonly Dictionary<IStatisticsItemSource, int> purpleCounter = [];
-    private readonly Dictionary<IStatisticsItemSource, int> blueCounter = [];
+    private readonly Dictionary<IStatisticsItemConvertible, int> orangeUpCounter = [];
+    private readonly Dictionary<IStatisticsItemConvertible, int> purpleUpCounter = [];
+    private readonly Dictionary<IStatisticsItemConvertible, int> orangeCounter = [];
+    private readonly Dictionary<IStatisticsItemConvertible, int> purpleCounter = [];
+    private readonly Dictionary<IStatisticsItemConvertible, int> blueCounter = [];
 
     private int totalCountTracker;
 
@@ -37,18 +37,18 @@ internal sealed class HistoryWishBuilder
         switch (ConfigType)
         {
             case GachaType.ActivityAvatar or GachaType.SpecialActivityAvatar:
-                orangeUpCounter = gachaEvent.UpOrangeList.Select(id => context.IdAvatarMap[id]).ToDictionary(a => (IStatisticsItemSource)a, a => 0);
-                purpleUpCounter = gachaEvent.UpPurpleList.Select(id => context.IdAvatarMap[id]).ToDictionary(a => (IStatisticsItemSource)a, a => 0);
+                orangeUpCounter = gachaEvent.UpOrangeList.Select(id => context.IdAvatarMap[id]).ToDictionary(a => (IStatisticsItemConvertible)a, a => 0);
+                purpleUpCounter = gachaEvent.UpPurpleList.Select(id => context.IdAvatarMap[id]).ToDictionary(a => (IStatisticsItemConvertible)a, a => 0);
                 break;
             case GachaType.ActivityWeapon:
-                orangeUpCounter = gachaEvent.UpOrangeList.Select(id => context.IdWeaponMap[id]).ToDictionary(w => (IStatisticsItemSource)w, w => 0);
-                purpleUpCounter = gachaEvent.UpPurpleList.Select(id => context.IdWeaponMap[id]).ToDictionary(w => (IStatisticsItemSource)w, w => 0);
+                orangeUpCounter = gachaEvent.UpOrangeList.Select(id => context.IdWeaponMap[id]).ToDictionary(w => (IStatisticsItemConvertible)w, w => 0);
+                purpleUpCounter = gachaEvent.UpPurpleList.Select(id => context.IdWeaponMap[id]).ToDictionary(w => (IStatisticsItemConvertible)w, w => 0);
                 break;
             case GachaType.ActivityCity:
 
                 // Avatars are less than weapons, so we try to get the value from avatar map first
-                orangeUpCounter = gachaEvent.UpOrangeList.Select(id => (IStatisticsItemSource?)context.IdAvatarMap.GetValueOrDefault(id) ?? context.IdWeaponMap[id]).ToDictionary(c => c, c => 0);
-                purpleUpCounter = gachaEvent.UpPurpleList.Select(id => (IStatisticsItemSource?)context.IdAvatarMap.GetValueOrDefault(id) ?? context.IdWeaponMap[id]).ToDictionary(c => c, c => 0);
+                orangeUpCounter = gachaEvent.UpOrangeList.Select(id => (IStatisticsItemConvertible?)context.IdAvatarMap.GetValueOrDefault(id) ?? context.IdWeaponMap[id]).ToDictionary(c => c, c => 0);
+                purpleUpCounter = gachaEvent.UpPurpleList.Select(id => (IStatisticsItemConvertible?)context.IdAvatarMap.GetValueOrDefault(id) ?? context.IdWeaponMap[id]).ToDictionary(c => c, c => 0);
                 break;
         }
     }
@@ -74,7 +74,7 @@ internal sealed class HistoryWishBuilder
     /// </summary>
     /// <param name="item">物品</param>
     /// <returns>是否为Up物品</returns>
-    public bool IncreaseOrange(IStatisticsItemSource item)
+    public bool IncreaseOrange(IStatisticsItemConvertible item)
     {
         orangeCounter.IncreaseOne(item);
         ++totalCountTracker;
@@ -86,7 +86,7 @@ internal sealed class HistoryWishBuilder
     /// 计数四星物品
     /// </summary>
     /// <param name="item">物品</param>
-    public void IncreasePurple(IStatisticsItemSource item)
+    public void IncreasePurple(IStatisticsItemConvertible item)
     {
         purpleUpCounter.TryIncreaseOne(item);
         purpleCounter.IncreaseOne(item);
@@ -97,7 +97,7 @@ internal sealed class HistoryWishBuilder
     /// 计数三星武器
     /// </summary>
     /// <param name="item">武器</param>
-    public void IncreaseBlue(IStatisticsItemSource item)
+    public void IncreaseBlue(IStatisticsItemConvertible item)
     {
         blueCounter.IncreaseOne(item);
         ++totalCountTracker;

src/Snap.Hutao/Snap.Hutao/Service/GachaLog/Factory/HutaoStatisticsFactory.cs

@@ -55,7 +55,7 @@ internal sealed class HutaoStatisticsFactory
 
         foreach (ref readonly ItemCount item in CollectionsMarshal.AsSpan(items))
         {
-            IStatisticsItemSource source = item.Item.StringLength() switch
+            IStatisticsItemConvertible source = item.Item.StringLength() switch
             {
                 8U => context.GetAvatar(item.Item),
                 5U => context.GetWeapon(item.Item),

src/Snap.Hutao/Snap.Hutao/Service/GachaLog/Factory/TypedWishSummaryBuilder.cs

@@ -44,7 +44,7 @@ internal sealed class TypedWishSummaryBuilder
     /// <param name="item">祈愿物品</param>
     /// <param name="source">对应武器</param>
     /// <param name="isUp">是否为Up物品</param>
-    public void Track(GachaItem item, ISummaryItemSource source, bool isUp)
+    public void Track(GachaItem item, ISummaryItemConvertible source, bool isUp)
     {
         if (!context.TypeEvaluator(item.GachaType))
         {

src/Snap.Hutao/Snap.Hutao/Service/GachaLog/GachaLogServiceMetadataContext.cs

@@ -59,7 +59,7 @@ internal sealed class GachaLogServiceMetadataContext : IMetadataContext,
         return result;
     }
 
-    public INameQuality GetNameQualityByItemId(uint id)
+    public INameQualityAccess GetNameQualityByItemId(uint id)
     {
         uint place = id.StringLength();
         return place switch

src/Snap.Hutao/Snap.Hutao/Service/Game/Scheme/LaunchScheme.cs

@@ -45,6 +45,10 @@ internal class LaunchScheme : IEquatable<ChannelOptions>
     /// </summary>
     public int LauncherId { get; private protected set; }
 
+    public string HoyoPlayLauncherId { get; private protected set; } = default!;
+
+    public string HoyoPlayGameId { get; private protected set; } = default!;
+
     /// <summary>
     /// API Key
     /// </summary>

src/Snap.Hutao/Snap.Hutao/Service/Game/Scheme/LaunchSchemeBilibili.cs

@@ -9,11 +9,15 @@ internal sealed class LaunchSchemeBilibili : LaunchScheme
 {
     private const int SdkStaticLauncherBilibiliId = 17;
     private const string SdkStaticLauncherBilibiliKey = "KAtdSsoQ";
+    private const string HoyoPlayLauncherBilibiliId = "umfgRO5gh5";
+    private const string HoyoPlayGameBilibiliId = "T2S0Gz4Dr2";
 
     public LaunchSchemeBilibili(SubChannelType subChannel, bool isNotCompatOnly = true)
     {
         LauncherId = SdkStaticLauncherBilibiliId;
         Key = SdkStaticLauncherBilibiliKey;
+        HoyoPlayLauncherId = HoyoPlayLauncherBilibiliId;
+        HoyoPlayGameId = HoyoPlayGameBilibiliId;
         Channel = ChannelType.Bili;
         SubChannel = subChannel;
         IsOversea = false;

src/Snap.Hutao/Snap.Hutao/Service/Game/Scheme/LaunchSchemeChinese.cs

@@ -9,11 +9,15 @@ internal sealed class LaunchSchemeChinese : LaunchScheme
 {
     private const int SdkStaticLauncherChineseId = 18;
     private const string SdkStaticLauncherChineseKey = "eYd89JmJ";
+    private const string HoyoPlayLauncherChineseId = "jGHBHlcOq1";
+    private const string HoyoPlayGameChineseId = "1Z8W5NHUQb";
 
     public LaunchSchemeChinese(ChannelType channel, SubChannelType subChannel, bool isNotCompatOnly = true)
     {
         LauncherId = SdkStaticLauncherChineseId;
         Key = SdkStaticLauncherChineseKey;
+        HoyoPlayLauncherId = HoyoPlayLauncherChineseId;
+        HoyoPlayGameId = HoyoPlayGameChineseId;
         Channel = channel;
         SubChannel = subChannel;
         IsOversea = false;

src/Snap.Hutao/Snap.Hutao/Service/Game/Scheme/LaunchSchemeOversea.cs

@@ -9,11 +9,15 @@ internal sealed class LaunchSchemeOversea : LaunchScheme
 {
     private const int SdkStaticLauncherOverseaId = 10;
     private const string SdkStaticLauncherOverseaKey = "gcStgarh";
+    private const string HoyoPlayLauncherOverseaId = "VYTpXlbWo8";
+    private const string HoyoPlayGameOverseaId = "gopR6Cufr3";
 
     public LaunchSchemeOversea(ChannelType channel, SubChannelType subChannel, bool isNotCompatOnly = true)
     {
         LauncherId = SdkStaticLauncherOverseaId;
         Key = SdkStaticLauncherOverseaKey;
+        HoyoPlayLauncherId = HoyoPlayLauncherOverseaId;
+        HoyoPlayGameId = HoyoPlayGameOverseaId;
         Channel = channel;
         SubChannel = subChannel;
         IsOversea = true;

src/Snap.Hutao/Snap.Hutao/Service/Game/Unlocker/GameFpsAddress.cs

@@ -3,7 +3,6 @@
 
 using Snap.Hutao.Core.ExceptionService;
 using Snap.Hutao.Win32.Foundation;
-using Snap.Hutao.Win32.Memory;
 using System.Diagnostics;
 using static Snap.Hutao.Win32.Kernel32;
 

src/Snap.Hutao/Snap.Hutao/Service/Inventory/IInventoryDbService.cs

@@ -2,16 +2,21 @@
 // Licensed under the MIT license.
 
 using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Service.Abstraction;
 
 namespace Snap.Hutao.Service.Inventory;
 
-internal interface IInventoryDbService
+internal interface IInventoryDbService : IAppDbService<InventoryItem>
 {
-    ValueTask AddInventoryItemRangeByProjectId(List<InventoryItem> items);
+    ValueTask AddInventoryItemRangeByProjectIdAsync(List<InventoryItem> items, CancellationToken token = default);
 
-    ValueTask RemoveInventoryItemRangeByProjectId(Guid projectId);
+    ValueTask RemoveInventoryItemRangeByProjectIdAsync(Guid projectId, CancellationToken token = default);
 
     void UpdateInventoryItem(InventoryItem item);
 
-    ValueTask UpdateInventoryItemAsync(InventoryItem item);
+    ValueTask UpdateInventoryItemAsync(InventoryItem item, CancellationToken token = default);
+
+    List<InventoryItem> GetInventoryItemListByProjectId(Guid projectId);
+
+    ValueTask<List<InventoryItem>> GetInventoryItemListByProjectIdAsync(Guid projectId, CancellationToken token = default);
 }

src/Snap.Hutao/Snap.Hutao/Service/Inventory/IInventoryService.cs

@@ -1,8 +1,17 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Service.Cultivation;
+using Snap.Hutao.ViewModel.Cultivation;
+
 namespace Snap.Hutao.Service.Inventory;
 
 internal interface IInventoryService
 {
+    List<InventoryItemView> GetInventoryItemViews(CultivateProject cultivateProject, ICultivationMetadataContext context, ICommand saveCommand);
+
+    void SaveInventoryItem(InventoryItemView item);
+
+    ValueTask RefreshInventoryAsync(CultivateProject project);
 }

src/Snap.Hutao/Snap.Hutao/Service/Inventory/InventoryDbService.cs

@@ -1,10 +1,8 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using Microsoft.EntityFrameworkCore;
-using Snap.Hutao.Core.Database;
 using Snap.Hutao.Model.Entity;
-using Snap.Hutao.Model.Entity.Database;
+using Snap.Hutao.Service.Abstraction;
 
 namespace Snap.Hutao.Service.Inventory;
 
@@ -14,43 +12,35 @@ internal sealed partial class InventoryDbService : IInventoryDbService
 {
     private readonly IServiceProvider serviceProvider;
 
-    public async ValueTask RemoveInventoryItemRangeByProjectId(Guid projectId)
+    public IServiceProvider ServiceProvider { get => serviceProvider; }
+
+    public async ValueTask RemoveInventoryItemRangeByProjectIdAsync(Guid projectId, CancellationToken token = default)
     {
-        using (IServiceScope scope = serviceProvider.CreateScope())
-        {
-            AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-            await appDbContext.InventoryItems
-                .AsNoTracking()
-                .Where(a => a.ProjectId == projectId && a.ItemId != 202U) // 摩拉
-                .ExecuteDeleteAsync()
-                .ConfigureAwait(false);
-        }
+        await this.DeleteAsync(i => i.ProjectId == projectId, token).ConfigureAwait(false);
     }
 
-    public async ValueTask AddInventoryItemRangeByProjectId(List<InventoryItem> items)
+    public async ValueTask AddInventoryItemRangeByProjectIdAsync(List<InventoryItem> items, CancellationToken token = default)
     {
-        using (IServiceScope scope = serviceProvider.CreateScope())
-        {
-            AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-            await appDbContext.InventoryItems.AddRangeAndSaveAsync(items).ConfigureAwait(false);
-        }
+        await this.AddRangeAsync(items, token).ConfigureAwait(false);
     }
 
     public void UpdateInventoryItem(InventoryItem item)
     {
-        using (IServiceScope scope = serviceProvider.CreateScope())
-        {
-            AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-            appDbContext.InventoryItems.UpdateAndSave(item);
-        }
+        this.Update(item);
     }
 
-    public async ValueTask UpdateInventoryItemAsync(InventoryItem item)
+    public async ValueTask UpdateInventoryItemAsync(InventoryItem item, CancellationToken token = default)
     {
-        using (IServiceScope scope = serviceProvider.CreateScope())
-        {
-            AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-            await appDbContext.InventoryItems.UpdateAndSaveAsync(item).ConfigureAwait(false);
-        }
+        await this.UpdateAsync(item, token).ConfigureAwait(false);
+    }
+
+    public List<InventoryItem> GetInventoryItemListByProjectId(Guid projectId)
+    {
+        return this.List(i => i.ProjectId == projectId);
+    }
+
+    public ValueTask<List<InventoryItem>> GetInventoryItemListByProjectIdAsync(Guid projectId, CancellationToken token = default)
+    {
+        return this.ListAsync(i => i.ProjectId == projectId, token);
     }
 }

src/Snap.Hutao/Snap.Hutao/Service/Inventory/InventoryService.cs

@@ -1,9 +1,83 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Model.Metadata.Item;
+using Snap.Hutao.Service.Cultivation;
+using Snap.Hutao.Service.Metadata.ContextAbstraction;
+using Snap.Hutao.Service.Notification;
+using Snap.Hutao.Service.User;
+using Snap.Hutao.ViewModel.Cultivation;
+using Snap.Hutao.ViewModel.User;
+using Snap.Hutao.Web.Hoyolab.Takumi.Event.Calculate;
+using Snap.Hutao.Web.Response;
+
 namespace Snap.Hutao.Service.Inventory;
 
-[Injection(InjectAs.Transient)]
-internal sealed class InventoryService : IInventoryService
+[ConstructorGenerated]
+[Injection(InjectAs.Singleton, typeof(IInventoryService))]
+internal sealed partial class InventoryService : IInventoryService
 {
+    private readonly MinimalPromotionDelta minimalPromotionDelta;
+    private readonly IServiceScopeFactory serviceScopeFactory;
+    private readonly IInventoryDbService inventoryDbService;
+    private readonly IInfoBarService infoBarService;
+    private readonly IUserService userService;
+
+    /// <inheritdoc/>
+    public List<InventoryItemView> GetInventoryItemViews(CultivateProject cultivateProject, ICultivationMetadataContext context, ICommand saveCommand)
+    {
+        Guid projectId = cultivateProject.InnerId;
+        List<InventoryItem> entities = inventoryDbService.GetInventoryItemListByProjectId(projectId);
+
+        List<InventoryItemView> results = [];
+        foreach (Material meta in context.EnumerateInventoryMaterial())
+        {
+            InventoryItem entity = entities.SingleOrDefault(e => e.ItemId == meta.Id) ?? InventoryItem.From(projectId, meta.Id);
+            results.Add(new(entity, meta, saveCommand));
+        }
+
+        return results;
+    }
+
+    /// <inheritdoc/>
+    public void SaveInventoryItem(InventoryItemView item)
+    {
+        inventoryDbService.UpdateInventoryItem(item.Entity);
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask RefreshInventoryAsync(CultivateProject project)
+    {
+        List<AvatarPromotionDelta> deltas = await minimalPromotionDelta.GetAsync().ConfigureAwait(false);
+
+        BatchConsumption? batchConsumption = default;
+        using (IServiceScope scope = serviceScopeFactory.CreateScope())
+        {
+            if (!UserAndUid.TryFromUser(userService.Current, out UserAndUid? userAndUid))
+            {
+                infoBarService.Warning(SH.MustSelectUserAndUid);
+                return;
+            }
+
+            CalculateClient calculateClient = scope.ServiceProvider.GetRequiredService<CalculateClient>();
+
+            Response<BatchConsumption>? resp = await calculateClient
+                .BatchComputeAsync(userAndUid, deltas, true)
+                .ConfigureAwait(false);
+
+            if (!resp.IsOk())
+            {
+                return;
+            }
+
+            batchConsumption = resp.Data;
+        }
+
+        if (batchConsumption is { OverallConsume: { } items })
+        {
+            await inventoryDbService.RemoveInventoryItemRangeByProjectIdAsync(project.InnerId).ConfigureAwait(false);
+            await inventoryDbService.AddInventoryItemRangeByProjectIdAsync(items.SelectList(item => InventoryItem.From(project.InnerId, item.Id, (uint)((int)item.Num - item.LackNum)))).ConfigureAwait(false);
+        }
+    }
 }

src/Snap.Hutao/Snap.Hutao/Service/Inventory/MinimalPromotionDelta.cs

@@ -0,0 +1,165 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Google.OrTools.LinearSolver;
+using Microsoft.Extensions.Caching.Memory;
+using Snap.Hutao.Core;
+using Snap.Hutao.Core.Diagnostics;
+using Snap.Hutao.Core.ExceptionService;
+using Snap.Hutao.Model.Metadata.Abstraction;
+using Snap.Hutao.Model.Primitive;
+using Snap.Hutao.Service.Metadata;
+using Snap.Hutao.Web.Hoyolab.Takumi.Event.Calculate;
+using System.Runtime.InteropServices;
+using MetadataAvatar = Snap.Hutao.Model.Metadata.Avatar.Avatar;
+using MetadataWeapon = Snap.Hutao.Model.Metadata.Weapon.Weapon;
+
+namespace Snap.Hutao.Service.Inventory;
+
+[ConstructorGenerated]
+[Injection(InjectAs.Singleton)]
+internal sealed partial class MinimalPromotionDelta
+{
+    private const string CacheKey = $"{nameof(MinimalPromotionDelta)}.Cache";
+
+    private readonly ILogger<MinimalPromotionDelta> logger;
+    private readonly IMetadataService metadataService;
+    private readonly IMemoryCache memoryCache;
+
+    public async ValueTask<List<AvatarPromotionDelta>> GetAsync()
+    {
+        if (memoryCache.TryGetRequiredValue(CacheKey, out List<AvatarPromotionDelta>? cache))
+        {
+            return cache;
+        }
+
+        List<ICultivationItemsAccess> cultivationItemsEntryList =
+        [
+            .. (await metadataService.GetAvatarListAsync().ConfigureAwait(false)).Where(a => a.BeginTime <= DateTimeOffset.Now),
+            .. (await metadataService.GetWeaponListAsync().ConfigureAwait(false)).Where(w => w.Quality >= Model.Intrinsic.QualityType.QUALITY_BLUE),
+        ];
+
+        List<ICultivationItemsAccess> minimal;
+        using (ValueStopwatch.MeasureExecution(logger))
+        {
+            minimal = Minimize(cultivationItemsEntryList);
+        }
+
+        // Gurantee the order of avatar and weapon
+        // Make sure weapons can have avatar to attach
+        minimal.Sort(CultivationItemsAccessComparer.Shared);
+        return memoryCache.Set(CacheKey, ToPromotionDeltaList(minimal));
+    }
+
+    private static List<ICultivationItemsAccess> Minimize(List<ICultivationItemsAccess> cultivationItems)
+    {
+        using (Solver? solver = Solver.CreateSolver("SCIP"))
+        {
+            ArgumentNullException.ThrowIfNull(solver);
+
+            Objective objective = solver.Objective();
+            objective.SetMinimization();
+
+            Dictionary<ICultivationItemsAccess, Variable> itemVariableMap = [];
+            foreach (ref readonly ICultivationItemsAccess item in CollectionsMarshal.AsSpan(cultivationItems))
+            {
+                Variable variable = solver.MakeBoolVar(item.Name);
+                itemVariableMap[item] = variable;
+                objective.SetCoefficient(variable, 1);
+            }
+
+            Dictionary<MaterialId, Constraint> materialConstraintMap = [];
+            foreach (ref readonly ICultivationItemsAccess item in CollectionsMarshal.AsSpan(cultivationItems))
+            {
+                foreach (ref readonly MaterialId materialId in CollectionsMarshal.AsSpan(item.CultivationItems))
+                {
+                    ref Constraint? constraint = ref CollectionsMarshal.GetValueRefOrAddDefault(materialConstraintMap, materialId, out _);
+                    constraint ??= solver.MakeConstraint(1, double.PositiveInfinity, $"{materialId}");
+                    constraint.SetCoefficient(itemVariableMap[item], 1);
+                }
+            }
+
+            Solver.ResultStatus status = solver.Solve();
+            HutaoException.ThrowIf(status != Solver.ResultStatus.OPTIMAL, "Unable to solve minimal item set");
+
+            List<ICultivationItemsAccess> results = [];
+            foreach ((ICultivationItemsAccess item, Variable variable) in itemVariableMap)
+            {
+                if (variable.SolutionValue() > 0.5)
+                {
+                    results.Add(item);
+                }
+            }
+
+            return results;
+        }
+    }
+
+    private static List<AvatarPromotionDelta> ToPromotionDeltaList(List<ICultivationItemsAccess> cultivationItems)
+    {
+        List<AvatarPromotionDelta> deltas = [];
+        int currentWeaponEmptyAvatarIndex = 0;
+
+        foreach (ref readonly ICultivationItemsAccess item in CollectionsMarshal.AsSpan(cultivationItems))
+        {
+            switch (item)
+            {
+                case MetadataAvatar avatar:
+                    deltas.Add(new()
+                    {
+                        AvatarId = avatar.Id,
+                        AvatarLevelCurrent = 1,
+                        AvatarLevelTarget = 90,
+                        SkillList = avatar.SkillDepot.CompositeSkillsNoInherents().SelectList(skill => new PromotionDelta()
+                        {
+                            Id = skill.GroupId,
+                            LevelCurrent = 1,
+                            LevelTarget = 10,
+                        }),
+                    });
+
+                    break;
+
+                case MetadataWeapon weapon:
+                    AvatarPromotionDelta delta;
+                    if (currentWeaponEmptyAvatarIndex < deltas.Count)
+                    {
+                        delta = deltas[currentWeaponEmptyAvatarIndex++];
+                    }
+                    else
+                    {
+                        delta = new();
+                        deltas.Add(delta);
+                    }
+
+                    delta.Weapon = new()
+                    {
+                        Id = weapon.Id,
+                        LevelCurrent = 1,
+                        LevelTarget = 90,
+                    };
+
+                    break;
+            }
+        }
+
+        return deltas;
+    }
+
+    private sealed class CultivationItemsAccessComparer : IComparer<ICultivationItemsAccess>
+    {
+        private static readonly LazySlim<CultivationItemsAccessComparer> LazyShared = new(() => new());
+
+        public static CultivationItemsAccessComparer Shared { get => LazyShared.Value; }
+
+        public int Compare(ICultivationItemsAccess? x, ICultivationItemsAccess? y)
+        {
+            return (x, y) switch
+            {
+                (MetadataAvatar, MetadataWeapon) => -1,
+                (MetadataWeapon, MetadataAvatar) => 1,
+                _ => 0,
+            };
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Service/Job/DailyNoteRefreshJobScheduler.cs

@@ -25,8 +25,8 @@ internal sealed partial class DailyNoteRefreshJobScheduler : IJobScheduler
 
         ITrigger dailyNoteTrigger = TriggerBuilder.Create()
             .WithIdentity(JobIdentity.DailyNoteRefreshTriggerName, JobIdentity.DailyNoteGroupName)
-            .StartNow()
-            .WithSimpleSchedule(builder => builder.WithIntervalInMinutes(interval).RepeatForever())
+            .WithSimpleSchedule(builder => builder.WithIntervalInSeconds(interval).RepeatForever())
+            .StartAt(DateTimeOffset.Now.AddSeconds(interval))
             .Build();
 
         await scheduler.ScheduleJob(dailyNoteJob, dailyNoteTrigger).ConfigureAwait(false);

src/Snap.Hutao/Snap.Hutao/Service/Metadata/ContextAbstraction/IMetadataListProfilePictureSource.cs

@@ -0,0 +1,11 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Metadata.Avatar;
+
+namespace Snap.Hutao.Service.Metadata.ContextAbstraction;
+
+internal interface IMetadataListProfilePictureSource
+{
+    public List<ProfilePicture> ProfilePictures { get; set; }
+}

src/Snap.Hutao/Snap.Hutao/Service/Metadata/ContextAbstraction/MetadataServiceContextExtension.cs

@@ -38,6 +38,11 @@ internal static class MetadataServiceContextExtension
                 listMaterialSource.Materials = await metadataService.GetMaterialListAsync(token).ConfigureAwait(false);
             }
 
+            if (context is IMetadataListProfilePictureSource dictionaryIdProfilePictureSource)
+            {
+                dictionaryIdProfilePictureSource.ProfilePictures = await metadataService.GetProfilePictureListAsync(token).ConfigureAwait(false);
+            }
+
             if (context is IMetadataListReliquaryMainAffixLevelSource listReliquaryMainAffixLevelSource)
             {
                 listReliquaryMainAffixLevelSource.ReliquaryMainAffixLevels = await metadataService.GetReliquaryMainAffixLevelListAsync(token).ConfigureAwait(false);

src/Snap.Hutao/Snap.Hutao/Service/Metadata/MetadataFileNames.cs

@@ -16,6 +16,7 @@ internal static class MetadataFileNames
     public const string FileNameMaterial = "Material";
     public const string FileNameMonster = "Monster";
     public const string FileNameMonsterCurve = "MonsterCurve";
+    public const string FileNameProfilePicture = "ProfilePicture";
     public const string FileNameReliquary = "Reliquary";
     public const string FileNameReliquaryAffixWeight = "ReliquaryAffixWeight";
     public const string FileNameReliquaryMainAffix = "ReliquaryMainAffix";

src/Snap.Hutao/Snap.Hutao/Service/Metadata/MetadataServiceListExtension.cs

@@ -70,6 +70,11 @@ internal static class MetadataServiceListExtension
         return metadataService.FromCacheOrFileAsync<List<GrowCurve>>(FileNameMonsterCurve, token);
     }
 
+    public static ValueTask<List<ProfilePicture>> GetProfilePictureListAsync(this IMetadataService metadataService, CancellationToken token = default)
+    {
+        return metadataService.FromCacheOrFileAsync<List<ProfilePicture>>(FileNameProfilePicture, token);
+    }
+
     public static ValueTask<List<Reliquary>> GetReliquaryListAsync(this IMetadataService metadataService, CancellationToken token = default)
     {
         return metadataService.FromCacheOrFileAsync<List<Reliquary>>(FileNameReliquary, token);

src/Snap.Hutao/Snap.Hutao/Service/Notification/IInfoBarService.cs

@@ -1,7 +1,6 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using Microsoft.UI.Xaml.Controls;
 using System.Collections.ObjectModel;
 
 namespace Snap.Hutao.Service.Notification;
@@ -9,7 +8,7 @@ namespace Snap.Hutao.Service.Notification;
 [HighQuality]
 internal interface IInfoBarService
 {
-    ObservableCollection<InfoBar> Collection { get; }
+    ObservableCollection<InfoBarOptions> Collection { get; }
 
     void PrepareInfoBarAndShow(Action<IInfoBarOptionsBuilder> configure);
 }

src/Snap.Hutao/Snap.Hutao/Service/Notification/InfoBarOptions.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 
 using Microsoft.UI.Xaml.Controls;
-using Microsoft.UI.Xaml.Controls.Primitives;
 
 namespace Snap.Hutao.Service.Notification;
 
@@ -16,7 +15,9 @@ internal sealed class InfoBarOptions
 
     public object? Content { get; set; }
 
-    public ButtonBase? ActionButton { get; set; }
+    public string? ActionButtonContent { get; set; }
+
+    public ICommand? ActionButtonCommand { get; set; }
 
     public int MilliSecondsDelay { get; set; }
 }

src/Snap.Hutao/Snap.Hutao/Service/Notification/InfoBarOptionsBuilderExtension.cs

@@ -2,8 +2,6 @@
 // Licensed under the MIT license.
 
 using Microsoft.UI.Xaml.Controls;
-using Microsoft.UI.Xaml.Controls.Primitives;
-using Snap.Hutao.Control.Builder.ButtonBase;
 using Snap.Hutao.Core.Abstraction.Extension;
 
 namespace Snap.Hutao.Service.Notification;
@@ -38,20 +36,17 @@ internal static class InfoBarOptionsBuilderExtension
         return builder;
     }
 
-    public static IInfoBarOptionsBuilder SetActionButton<TBuilder, TButton>(this TBuilder builder, Action<ButtonBaseBuilder<TButton>> configureButton)
+    public static IInfoBarOptionsBuilder SetActionButtonContent<TBuilder>(this TBuilder builder, string? buttonContent)
         where TBuilder : IInfoBarOptionsBuilder
-        where TButton : ButtonBase, new()
     {
-        ButtonBaseBuilder<TButton> buttonBaseBuilder = new ButtonBaseBuilder<TButton>().Configure(configureButton);
-        builder.Configure(builder => builder.Options.ActionButton = buttonBaseBuilder.Button);
+        builder.Configure(builder => builder.Options.ActionButtonContent = buttonContent);
         return builder;
     }
 
-    public static IInfoBarOptionsBuilder SetActionButton<TBuilder>(this TBuilder builder, Action<ButtonBuilder> configureButton)
+    public static IInfoBarOptionsBuilder SetActionButtonCommand<TBuilder>(this TBuilder builder, ICommand? buttonCommand)
         where TBuilder : IInfoBarOptionsBuilder
     {
-        ButtonBuilder buttonBaseBuilder = new ButtonBuilder().Configure(configureButton);
-        builder.Configure(builder => builder.Options.ActionButton = buttonBaseBuilder.Button);
+        builder.Configure(builder => builder.Options.ActionButtonCommand = buttonCommand);
         return builder;
     }
 

src/Snap.Hutao/Snap.Hutao/Service/Notification/InfoBarService.cs

@@ -1,11 +1,8 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using Microsoft.UI.Xaml.Controls;
-using Microsoft.UI.Xaml.Media.Animation;
 using Snap.Hutao.Core.Abstraction.Extension;
 using System.Collections.ObjectModel;
-using Windows.Foundation;
 
 namespace Snap.Hutao.Service.Notification;
 
@@ -17,20 +14,16 @@ internal sealed class InfoBarService : IInfoBarService
     private readonly ILogger<InfoBarService> logger;
     private readonly ITaskContext taskContext;
 
-    private readonly TypedEventHandler<InfoBar, InfoBarClosedEventArgs> infobarClosedEventHandler;
-
-    private ObservableCollection<InfoBar>? collection;
+    private ObservableCollection<InfoBarOptions>? collection;
 
     public InfoBarService(IServiceProvider serviceProvider)
     {
         logger = serviceProvider.GetRequiredService<ILogger<InfoBarService>>();
         taskContext = serviceProvider.GetRequiredService<ITaskContext>();
-
-        infobarClosedEventHandler = OnInfoBarClosed;
     }
 
     /// <inheritdoc/>
-    public ObservableCollection<InfoBar> Collection
+    public ObservableCollection<InfoBarOptions> Collection
     {
         get => collection ??= [];
     }
@@ -51,33 +44,7 @@ internal sealed class InfoBarService : IInfoBarService
 
         await taskContext.SwitchToMainThreadAsync();
 
-        InfoBar infoBar = new()
-        {
-            Severity = builder.Options.Severity,
-            Title = builder.Options.Title,
-            Message = builder.Options.Message,
-            Content = builder.Options.Content,
-            IsOpen = true,
-            ActionButton = builder.Options.ActionButton,
-            Transitions = [new AddDeleteThemeTransition()],
-        };
-
-        infoBar.Closed += infobarClosedEventHandler;
         ArgumentNullException.ThrowIfNull(collection);
-        collection.Add(infoBar);
-
-        if (builder.Options.MilliSecondsDelay > 0)
-        {
-            await Delay.FromMilliSeconds(builder.Options.MilliSecondsDelay).ConfigureAwait(true);
-            collection.Remove(infoBar);
-            infoBar.IsOpen = false;
-        }
-    }
-
-    private void OnInfoBarClosed(InfoBar sender, InfoBarClosedEventArgs args)
-    {
-        ArgumentNullException.ThrowIfNull(collection);
-        taskContext.BeginInvokeOnMainThread(() => collection.Remove(sender));
-        sender.Closed -= infobarClosedEventHandler;
+        collection.Add(builder.Options);
     }
 }

src/Snap.Hutao/Snap.Hutao/Service/Notification/InfoBarServiceExtension.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 
 using Microsoft.UI.Xaml.Controls;
-using Snap.Hutao.Control.Builder.ButtonBase;
 using Snap.Hutao.Core.Abstraction.Extension;
 
 namespace Snap.Hutao.Service.Notification;
@@ -21,7 +20,7 @@ internal static class InfoBarServiceExtension
 
     public static void Information(this IInfoBarService infoBarService, string title, string message, string buttonContent, ICommand buttonCommand, int milliSeconds = 5000)
     {
-        infoBarService.Information(builder => builder.SetTitle(title).SetMessage(message).SetActionButton(buttonBuilder => buttonBuilder.SetContent(buttonContent).SetCommand(buttonCommand)).SetDelay(milliSeconds));
+        infoBarService.Information(builder => builder.SetTitle(title).SetMessage(message).SetActionButtonContent(buttonContent).SetActionButtonCommand(buttonCommand).SetDelay(milliSeconds));
     }
 
     public static void Information(this IInfoBarService infoBarService, Action<IInfoBarOptionsBuilder> configure)
@@ -56,7 +55,7 @@ internal static class InfoBarServiceExtension
 
     public static void Warning(this IInfoBarService infoBarService, string title, string message, string buttonContent, ICommand buttonCommand, int milliSeconds = 30000)
     {
-        infoBarService.Warning(builder => builder.SetTitle(title).SetMessage(message).SetActionButton(buttonBuilder => buttonBuilder.SetContent(buttonContent).SetCommand(buttonCommand)).SetDelay(milliSeconds));
+        infoBarService.Warning(builder => builder.SetTitle(title).SetMessage(message).SetActionButtonContent(buttonContent).SetActionButtonCommand(buttonCommand).SetDelay(milliSeconds));
     }
 
     public static void Warning(this IInfoBarService infoBarService, Action<IInfoBarOptionsBuilder> configure)
@@ -76,7 +75,7 @@ internal static class InfoBarServiceExtension
 
     public static void Error(this IInfoBarService infoBarService, string title, string message, string buttonContent, ICommand buttonCommand, int milliSeconds = 0)
     {
-        infoBarService.Error(builder => builder.SetTitle(title).SetMessage(message).SetActionButton(buttonBuilder => buttonBuilder.SetContent(buttonContent).SetCommand(buttonCommand)).SetDelay(milliSeconds));
+        infoBarService.Error(builder => builder.SetTitle(title).SetMessage(message).SetActionButtonContent(buttonContent).SetActionButtonCommand(buttonCommand).SetDelay(milliSeconds));
     }
 
     public static void Error(this IInfoBarService infoBarService, Exception ex, int milliSeconds = 0)
@@ -91,7 +90,7 @@ internal static class InfoBarServiceExtension
 
     public static void Error(this IInfoBarService infoBarService, Exception ex, string subtitle, string buttonContent, ICommand buttonCommand, int milliSeconds = 0)
     {
-        infoBarService.Error(builder => builder.SetTitle(ex.GetType().Name).SetMessage($"{subtitle}\n{ex.Message}").SetActionButton(buttonBuilder => buttonBuilder.SetContent(buttonContent).SetCommand(buttonCommand)).SetDelay(milliSeconds));
+        infoBarService.Error(builder => builder.SetTitle(ex.GetType().Name).SetMessage($"{subtitle}\n{ex.Message}").SetActionButtonContent(buttonContent).SetActionButtonCommand(buttonCommand).SetDelay(milliSeconds));
     }
 
     public static void Error(this IInfoBarService infoBarService, Action<IInfoBarOptionsBuilder> configure)

src/Snap.Hutao/Snap.Hutao/Service/Notification/ToastNotificationLifeTime.cs

@@ -1,7 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using CommunityToolkit.WinUI.Notifications;
+using Microsoft.Windows.AppNotifications;
 
 namespace Snap.Hutao.Service.Notification;
 
@@ -16,7 +16,8 @@ internal sealed class ToastNotificationLifeTime : IToastNotificationLifeTime
         // 用于在程序退出时尝试清除所有的系统通知
         try
         {
-            ToastNotificationManagerCompat.History.Clear();
+            AppNotificationManager.Default.RemoveAllAsync().AsTask().GetAwaiter().GetResult();
+            AppNotificationManager.Default.Unregister();
         }
         catch
         {

src/Snap.Hutao/Snap.Hutao/Service/User/IProfilePictureService.cs

@@ -0,0 +1,14 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Web.Hoyolab.Takumi.Binding;
+
+namespace Snap.Hutao.Service.User;
+
+internal interface IProfilePictureService
+{
+    ValueTask TryInitializeAsync(ViewModel.User.User user, CancellationToken token = default(CancellationToken));
+
+    ValueTask RefreshUserGameRoleAsync(UserGameRole userGameRole, CancellationToken token = default(CancellationToken));
+}

src/Snap.Hutao/Snap.Hutao/Service/User/IUidProfilePictureDbService.cs

@@ -0,0 +1,16 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Service.Abstraction;
+
+namespace Snap.Hutao.Service.User;
+
+internal interface IUidProfilePictureDbService : IAppDbService<UidProfilePicture>
+{
+    ValueTask<UidProfilePicture?> SingleUidProfilePictureOrDefaultByUidAsync(string uid, CancellationToken token = default);
+
+    ValueTask UpdateUidProfilePictureAsync(UidProfilePicture profilePicture, CancellationToken token = default);
+
+    ValueTask DeleteUidProfilePictureByUidAsync(string uid, CancellationToken token = default);
+}

src/Snap.Hutao/Snap.Hutao/Service/User/IUserInitializationService.cs

@@ -1,6 +1,8 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Web.Hoyolab.Takumi.Binding;
+
 namespace Snap.Hutao.Service.User;
 
 internal interface IUserInitializationService

src/Snap.Hutao/Snap.Hutao/Service/User/IUserMetadataContext.cs

@@ -0,0 +1,9 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Service.Metadata.ContextAbstraction;
+
+namespace Snap.Hutao.Service.User;
+
+internal interface IUserMetadataContext : IMetadataContext,
+    IMetadataListProfilePictureSource;

src/Snap.Hutao/Snap.Hutao/Service/User/IUserService.cs

@@ -53,4 +53,6 @@ internal interface IUserService
     /// <param name="user">待移除的用户</param>
     /// <returns>任务</returns>
     ValueTask RemoveUserAsync(BindingUser user);
+
+    ValueTask RefreshProfilePictureAsync(UserGameRole userGameRole);
 }

src/Snap.Hutao/Snap.Hutao/Service/User/ProfilePictureService.cs

@@ -0,0 +1,109 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Model.Intrinsic;
+using Snap.Hutao.Service.Metadata;
+using Snap.Hutao.Service.Metadata.ContextAbstraction;
+using Snap.Hutao.Web.Enka;
+using Snap.Hutao.Web.Enka.Model;
+using Snap.Hutao.Web.Hoyolab.Takumi.Binding;
+
+namespace Snap.Hutao.Service.User;
+
+[ConstructorGenerated]
+[Injection(InjectAs.Singleton, typeof(IProfilePictureService))]
+internal sealed partial class ProfilePictureService : IProfilePictureService
+{
+    private readonly IUidProfilePictureDbService uidProfilePictureDbService;
+    private readonly IMetadataService metadataService;
+    private readonly IServiceProvider serviceProvider;
+    private readonly ITaskContext taskContext;
+
+    public async ValueTask TryInitializeAsync(ViewModel.User.User user, CancellationToken token = default)
+    {
+        foreach (UserGameRole userGameRole in user.UserGameRoles)
+        {
+            if (await uidProfilePictureDbService.SingleUidProfilePictureOrDefaultByUidAsync(userGameRole.GameUid, token).ConfigureAwait(false) is { } profilePicture)
+            {
+                if (await TryUpdateUserGameRoleAsync(userGameRole, profilePicture, token).ConfigureAwait(false))
+                {
+                    continue;
+                }
+            }
+
+            // Force update
+            await RefreshUserGameRoleAsync(userGameRole, token: token).ConfigureAwait(false);
+        }
+    }
+
+    public async ValueTask RefreshUserGameRoleAsync(UserGameRole userGameRole, CancellationToken token = default)
+    {
+        EnkaResponse? enkaResponse;
+        using (IServiceScope scope = serviceProvider.CreateScope())
+        {
+            EnkaClient enkaClient = scope.ServiceProvider
+                .GetRequiredService<EnkaClient>();
+
+            enkaResponse = await enkaClient.GetForwardPlayerInfoAsync(userGameRole, token).ConfigureAwait(false)
+                ?? await enkaClient.GetPlayerInfoAsync(userGameRole, token).ConfigureAwait(false);
+        }
+
+        if (enkaResponse is { PlayerInfo: { } playerInfo })
+        {
+            UidProfilePicture profilePicture = UidProfilePicture.From(userGameRole, playerInfo.ProfilePicture);
+
+            await uidProfilePictureDbService.DeleteUidProfilePictureByUidAsync(userGameRole.GameUid, token).ConfigureAwait(false);
+            await uidProfilePictureDbService.UpdateUidProfilePictureAsync(profilePicture, token).ConfigureAwait(false);
+
+            await TryUpdateUserGameRoleAsync(userGameRole, profilePicture, token).ConfigureAwait(false);
+        }
+    }
+
+    private async ValueTask<bool> TryUpdateUserGameRoleAsync(UserGameRole userGameRole, UidProfilePicture cache, CancellationToken token = default)
+    {
+        if (cache.RefreshTime.AddDays(15) < DateTimeOffset.Now)
+        {
+            return false;
+        }
+
+        if (!await metadataService.InitializeAsync().ConfigureAwait(false))
+        {
+            return false;
+        }
+
+        UserMetadataContext context = await metadataService.GetContextAsync<UserMetadataContext>(token).ConfigureAwait(false);
+
+        await taskContext.SwitchToMainThreadAsync();
+
+        // Most common to most rare
+        if (cache.ProfilePictureId is not 0U)
+        {
+            userGameRole.ProfilePictureIcon = context.ProfilePictures
+                .Single(p => p.Id == cache.ProfilePictureId)
+                .Icon;
+
+            return true;
+        }
+
+        if (cache.AvatarId is not 0U)
+        {
+            userGameRole.ProfilePictureIcon = context.ProfilePictures
+                .Single(p => p.UnlockType is ProfilePictureUnlockType.Avatar && p.UnlockParameter == cache.AvatarId)
+                .Icon;
+
+            return true;
+        }
+
+        if (cache.CostumeId is not 0U)
+        {
+            userGameRole.ProfilePictureIcon = context.ProfilePictures
+                .Single(p => p.UnlockType is ProfilePictureUnlockType.Costume && p.UnlockParameter == cache.CostumeId)
+                .Icon;
+
+            return true;
+        }
+
+        return false;
+    }
+}

src/Snap.Hutao/Snap.Hutao/Service/User/UidProfilePictureDbService.cs

@@ -0,0 +1,32 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.EntityFrameworkCore;
+using Snap.Hutao.Model.Entity;
+using Snap.Hutao.Service.Abstraction;
+
+namespace Snap.Hutao.Service.User;
+
+[ConstructorGenerated]
+[Injection(InjectAs.Singleton, typeof(IUidProfilePictureDbService))]
+internal sealed partial class UidProfilePictureDbService : IUidProfilePictureDbService
+{
+    private readonly IServiceProvider serviceProvider;
+
+    public IServiceProvider ServiceProvider { get => serviceProvider; }
+
+    public ValueTask<UidProfilePicture?> SingleUidProfilePictureOrDefaultByUidAsync(string uid, CancellationToken token = default)
+    {
+        return this.QueryAsync(query => query.SingleOrDefaultAsync(n => n.Uid == uid));
+    }
+
+    public async ValueTask UpdateUidProfilePictureAsync(UidProfilePicture profilePicture, CancellationToken token = default)
+    {
+        await this.UpdateAsync(profilePicture, token).ConfigureAwait(false);
+    }
+
+    public async ValueTask DeleteUidProfilePictureByUidAsync(string uid, CancellationToken token = default)
+    {
+        await this.DeleteAsync(profilePicture => profilePicture.Uid == uid, token).ConfigureAwait(false);
+    }
+}

src/Snap.Hutao/Snap.Hutao/Service/User/UserInitializationService.cs

@@ -16,6 +16,7 @@ namespace Snap.Hutao.Service.User;
 internal sealed partial class UserInitializationService : IUserInitializationService
 {
     private readonly IUserFingerprintService userFingerprintService;
+    private readonly IProfilePictureService profilePictureService;
     private readonly IServiceProvider serviceProvider;
 
     public async ValueTask<ViewModel.User.User> ResumeUserAsync(Model.Entity.User inner, CancellationToken token = default)
@@ -90,6 +91,7 @@ internal sealed partial class UserInitializationService : IUserInitializationSer
         }
 
         await userFingerprintService.TryInitializeAsync(user, token).ConfigureAwait(false);
+        await profilePictureService.TryInitializeAsync(user, token).ConfigureAwait(false);
 
         return user.IsInitialized = true;
     }

src/Snap.Hutao/Snap.Hutao/Service/User/UserMetadataContext.cs

@@ -0,0 +1,11 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Metadata.Avatar;
+
+namespace Snap.Hutao.Service.User;
+
+internal class UserMetadataContext : IUserMetadataContext
+{
+    public List<ProfilePicture> ProfilePictures { get; set; } = default!;
+}

src/Snap.Hutao/Snap.Hutao/Service/User/UserService.cs

@@ -21,6 +21,7 @@ namespace Snap.Hutao.Service.User;
 [Injection(InjectAs.Singleton, typeof(IUserService))]
 internal sealed partial class UserService : IUserService, IUserServiceUnsafe
 {
+    private readonly IProfilePictureService profilePictureService;
     private readonly IUserCollectionService userCollectionService;
     private readonly IServiceProvider serviceProvider;
     private readonly IUserDbService userDbService;
@@ -121,4 +122,9 @@ internal sealed partial class UserService : IUserService, IUserServiceUnsafe
 
         return true;
     }
+
+    public async ValueTask RefreshProfilePictureAsync(UserGameRole userGameRole)
+    {
+        await profilePictureService.RefreshUserGameRoleAsync(userGameRole).ConfigureAwait(false);
+    }
 }

src/Snap.Hutao/Snap.Hutao/Snap.Hutao.csproj

@@ -312,9 +312,9 @@
     <PackageReference Include="CommunityToolkit.WinUI.Controls.SettingsControls" Version="8.0.240109" />
     <PackageReference Include="CommunityToolkit.WinUI.Controls.TokenizingTextBox" Version="8.0.240109" />
     <PackageReference Include="CommunityToolkit.WinUI.Media" Version="8.0.240109" />
-    <PackageReference Include="CommunityToolkit.WinUI.Notifications" Version="7.1.2" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.5" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.5">
+    <PackageReference Include="Google.OrTools" Version="9.10.4067" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.6" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.6">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
@@ -329,7 +329,7 @@
     </PackageReference>
     <PackageReference Include="Microsoft.VisualStudio.Validation" Version="17.8.8" />
     <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.1" />
-    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.240428000" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.240607001" />
     <PackageReference Include="QRCoder" Version="1.5.1" />
     <PackageReference Include="Quartz.Extensions.DependencyInjection" Version="3.9.0" />
     <PackageReference Include="Snap.Discord.GameSDK" Version="1.6.0" />