Commit: master - CleanAuLait.Prism.WinUI3 (git)

Commit MetaInfo

• Revision: 684982186e889eb40e9dc0277d4349aef053aea8 (tree)
• Time: 2022-08-16 01:06:06
• Author: yoshy <yoshy.org.bitbucket@gz.j...>
• Commiter: yoshy

Log Message

initial revision

Change Summary

• add: Adaptor/Boundary/Gateway/UI/Dialog/IUserDialogProxy.cs
• add: Adaptor/Boundary/Gateway/UI/IShowChildWindowProxy.cs
• add: Adaptor/Controller/AsyncHandlerContextFactoryRegistrar.cs
• add: Adaptor/Controller/DI/RequestScopeGenerator.cs
• add: Adaptor/Controller/DI/RequestScopedProvider.cs
• add: Adaptor/Controller/Handler/AbstractErrorHandler.cs
• add: Adaptor/Controller/Handler/AsyncSimpleUserDialogErrorHandler.cs
• add: Adaptor/Controller/Handler/SimpleErrorHandler.cs
• add: Adaptor/Controller/HandlerContextFactoryRegistrar.cs
• add: CleanAuLait.Prism.WinUI3.csproj
• add: CleanAuLaitPrismWinUI3Module.cs
• add: Core/Resource/MessageRepository.cs
• add: Core/Resource/ResourceHelper.cs
• add: Gateway/UI/Dialog/UserDialogProxy.cs

Incremental Difference

--- /dev/null
+++ b/Adaptor/Boundary/Gateway/UI/Dialog/IUserDialogProxy.cs
@@ -0,0 +1,14 @@
+namespace CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog
+{
+    public interface IUserDialogProxy
+    {
+        void ShowInfo(string msg);
+        void ShowInfo(string msg, string caption);
+        void ShowWarn(string msg);
+        void ShowWarn(string msg, string caption);
+        void ShowError(Exception e);
+        void ShowError(Exception e, string caption);
+        void ShowError(string msg);
+        void ShowError(string msg, string caption);
+    }
+}
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Boundary/Gateway/UI/IShowChildWindowProxy.cs
@@ -0,0 +1,7 @@
+namespace CleanAuLait.Adaptor.Boundary.Gateway.UI
+{
+    public interface IShowChildWindowProxy
+    {
+        void ShowChildWindow();
+    }
+}

--- /dev/null
+++ b/Adaptor/Controller/AsyncHandlerContextFactoryRegistrar.cs
@@ -0,0 +1,24 @@
+using CleanAuLait.Adaptor.Boundary.Controller;
+using Prism.Ioc;
+
+namespace CleanAuLait.Adaptor.Controller
+{
+    public class AsyncHandlerContextFactoryRegistrar : 
+            AbstractHandlerContextFactoryRegistrar<IAsyncHandlerContextFactory, AsyncHandlerContextFactory>
+    {
+        private readonly IContainerRegistry containerRegistry;
+
+        public AsyncHandlerContextFactoryRegistrar(IContainerRegistry containerRegistry)
+        {
+            this.containerRegistry = containerRegistry;
+        }
+
+        public override void Register()
+        {
+            var factory = CreateFactoryFactory();
+
+            this.containerRegistry.RegisterSingleton<IAsyncHandlerContextFactory>(factory);
+        }
+
+    }
+}

--- /dev/null
+++ b/Adaptor/Controller/DI/RequestScopeGenerator.cs
@@ -0,0 +1,25 @@
+using CleanAuLait.Core.DI;
+using Prism.Ioc;
+
+namespace CleanAuLait.Adaptor.Controller.DI
+{
+    internal class RequestScopeGenerator : IRequestScopeGenerator
+    {
+        public IRequestScopedProvider CreateScope()
+        {
+            try
+            {
+                return new RequestScopedProvider(GetContainer().CreateScope());
+            }
+            catch (Exception e)
+            {
+                throw new DIException(e);
+            }
+        }
+
+        protected virtual IContainerProvider GetContainer()
+        {
+            return ContainerLocator.Container;
+        }
+    }
+}

--- /dev/null
+++ b/Adaptor/Controller/DI/RequestScopedProvider.cs
@@ -0,0 +1,32 @@
+using CleanAuLait.Core.DI;
+using Prism.Ioc;
+
+namespace CleanAuLait.Adaptor.Controller.DI;
+
+internal class RequestScopedProvider : IRequestScopedProvider
+{
+    private readonly IScopedProvider scopedProvider;
+
+    public RequestScopedProvider(IScopedProvider scopedProvider)
+    {
+        this.scopedProvider = scopedProvider;
+    }
+
+    public object Resolve(Type type)
+    {
+        try
+        {
+            return this.scopedProvider.Resolve(type);
+        }
+        catch (ContainerResolutionException e)
+        {
+            throw new DIException(e);
+        }
+    }
+
+    public void Dispose()
+    {
+        this.scopedProvider?.Dispose();
+    }
+
+}
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Controller/Handler/AbstractErrorHandler.cs
@@ -0,0 +1,40 @@
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog;
+using CleanAuLait.UseCase.Request;
+using CleanAuLait.UseCase.Response;
+
+namespace CleanAuLait.Adaptor.Controller.Handler
+{
+    public abstract class AbstractErrorHandler
+    {
+        private readonly IUserDialogProxy dialog;
+
+        public AbstractErrorHandler(IUserDialogProxy dialog)
+        {
+            this.dialog = dialog;
+        }
+
+        protected UseCaseResponse HandleResponse(UseCaseRequest _, UseCaseResponse res)
+        {
+            if (res == null)
+            {
+                res = UseCaseResponse.AbortWithSomeErrors<UseCaseResponse>(
+                        "[Bug Check] コマンドの処理結果が未設定です。ハンドラマップの設定漏れの可能性があります");
+            }
+
+            //string statusText = !String.IsNullOrEmpty(res.Message) ? res.Message : AppConst.STATUS_BAR_READY;
+
+            if (res.HasSomeErrors)
+            {
+                //dialog.ShowError(res.Message, req.UIInfo);
+                dialog.ShowError(res.Message);
+            }
+            else if (res.IsAborted)
+            {
+                //dialog.ShowInfo(res.Message, req.UIInfo);
+                dialog.ShowInfo(res.Message);
+            }
+
+            return res;
+        }
+    }
+}
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Controller/Handler/AsyncSimpleUserDialogErrorHandler.cs
@@ -0,0 +1,36 @@
+using CleanAuLait.Adaptor.Boundary.Controller;
+using CleanAuLait.Adaptor.Boundary.Controller.Handler;
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog;
+using CleanAuLait.UseCase.Request;
+using CleanAuLait.UseCase.Response;
+using NLog;
+
+namespace CleanAuLait.Adaptor.Controller.Handler
+{
+    public class AsyncSimpleUserDialogErrorHandler : AbstractErrorHandler, IAsyncRequestHandler
+    {
+        private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
+
+        public AsyncSimpleUserDialogErrorHandler(IUserDialogProxy dialog) : base(dialog)
+        {
+        }
+
+        public async Task<UseCaseResponse> HandleAsync(UseCaseRequest req, IAsyncHandlerContext context)
+        {
+            UseCaseResponse res;
+
+            try
+            {
+                res = await context.HandleNextAsync(req, context);
+            }
+            catch (Exception e)
+            {
+                logger.Error(e);
+                res = UseCaseResponse.AbortWithSomeErrors<UseCaseResponse>(
+                      $"Handling Async UseCase failed. {e.Message}");
+            }
+
+            return HandleResponse(req, res);
+        }
+    }
+}

--- /dev/null
+++ b/Adaptor/Controller/Handler/SimpleErrorHandler.cs
@@ -0,0 +1,36 @@
+using CleanAuLait.Adaptor.Boundary.Controller;
+using CleanAuLait.Adaptor.Boundary.Controller.Handler;
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog;
+using CleanAuLait.UseCase.Request;
+using CleanAuLait.UseCase.Response;
+using NLog;
+
+namespace CleanAuLait.Adaptor.Controller.Handler
+{
+    public class SimpleUserDialogErrorHandler : AbstractErrorHandler, IRequestHandler
+    {
+        private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
+
+        public SimpleUserDialogErrorHandler(IUserDialogProxy dialog) : base(dialog)
+        {
+        }
+
+        public UseCaseResponse Handle(UseCaseRequest req, IHandlerContext context)
+        {
+            UseCaseResponse res;
+
+            try
+            {
+                res = context.HandleNext(req, context);
+            }
+            catch (Exception e)
+            {
+                logger.Error(e);
+                res = UseCaseResponse.AbortWithSomeErrors<UseCaseResponse>(
+                      $"Handling UseCase failed. {e.Message}");
+            }
+
+            return HandleResponse(req, res);
+        }
+    }
+}

--- /dev/null
+++ b/Adaptor/Controller/HandlerContextFactoryRegistrar.cs
@@ -0,0 +1,23 @@
+using CleanAuLait.Adaptor.Boundary.Controller;
+using Prism.Ioc;
+
+namespace CleanAuLait.Adaptor.Controller
+{
+    public class HandlerContextFactoryRegistrar :
+            AbstractHandlerContextFactoryRegistrar<IHandlerContextFactory, HandlerContextFactory>
+    {
+        private readonly IContainerRegistry containerRegistry;
+
+        public HandlerContextFactoryRegistrar(IContainerRegistry containerRegistry)
+        {
+            this.containerRegistry = containerRegistry;
+        }
+
+        public override void Register()
+        {
+            var factory = CreateFactoryFactory();
+
+            this.containerRegistry.RegisterSingleton<IHandlerContextFactory>(factory);
+        }
+    }
+}

--- /dev/null
+++ b/CleanAuLait.Prism.WinUI3.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0-windows10.0.19041.0</TargetFramework>
+    <TargetPlatformMinVersion>10.0.19041.0</TargetPlatformMinVersion>
+    <RootNamespace>CleanAuLait.Prism.WinUI3</RootNamespace>
+    <RuntimeIdentifiers>win10-x86;win10-x64;win10-arm64</RuntimeIdentifiers>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<UseWinUI>true</UseWinUI>
+  </PropertyGroup>
+
+  <ItemGroup>
+      <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.1.4" />
+      <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.22621.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CleanAuLait\CleanAuLait.csproj" />
+    <ProjectReference Include="D:\Repo\gitroot\Prism\src\WinUi\Prism.Unity.WinUI\Prism.Unity.WinUI.csproj" />
+  </ItemGroup>
+</Project>

--- /dev/null
+++ b/CleanAuLaitPrismWinUI3Module.cs
@@ -0,0 +1,105 @@
+#if false
+using CleanAuLait.Adaptor.Boundary.Gateway.UI;
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog;
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog.Shell;
+using CleanAuLait.Adaptor.Boundary.Gateway.ViewModel.Dialog;
+using CleanAuLait.Adaptor.Gateway.UI;
+using CleanAuLait.Adaptor.Gateway.UI.Dialog;
+using CleanAuLait.Adaptor.Gateway.UI.Dialog.Service;
+using CleanAuLait.Adaptor.Gateway.UI.Dialog.Shell;
+using CleanAuLait.Adaptor.Gateway.ViewModel;
+using CleanAuLait.OuterEdge.UI.Dialog;
+#endif
+using NLog;
+using CleanAuLait.Adaptor.Controller.DI;
+using CleanAuLait.Core.Resource;
+using Prism.Ioc;
+using Prism.Modularity;
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog;
+using CleanAuLait.Adaptor.Gateway.UI.Dialog;
+#if false
+using Prism.Mvvm;
+using Prism.Services.Dialogs;
+#endif
+
+namespace CleanAuLait
+{
+    public class CleanAuLaitPrismWinUI3Module : IModule
+    {
+        private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
+
+        public void RegisterTypes(IContainerRegistry containerRegistry)
+        {
+            //
+            // Request Scope
+            //
+
+            containerRegistry.RegisterSingleton<IRequestScopeGenerator, RequestScopeGenerator>();
+
+            ///
+            /// Resources
+            ///
+
+            containerRegistry.RegisterSingleton<ICaptionFormatter, CaptionFormatter>();
+
+            //
+            // Dialog Proxy
+            //
+
+            containerRegistry.RegisterSingleton<IUserDialogProxy, UserDialogProxy>();
+#if false
+            containerRegistry.RegisterSingleton<IUniversalDialogProxy, UniversalDialogProxy>();
+
+            //
+            // Dialog Service
+            //
+
+            containerRegistry.RegisterSingleton<IDialogService, UniversalDialogService>();
+
+            //
+            // Dialog Proxy
+            //
+
+            containerRegistry.RegisterSingleton<IUserDialogProxy, UserDialogProxy>();
+            containerRegistry.RegisterSingleton<IUniversalDialogProxy, UniversalDialogProxy>();
+
+            //
+            // Dialog View Model
+            //
+
+            containerRegistry.RegisterSingleton<IUniversalDialogViewModel, UniversalDialogViewModel>();
+
+            containerRegistry.RegisterDialog<UniversalDialog, IUniversalDialogViewModel>();
+
+            //
+            // UI Proxy
+            //
+
+            containerRegistry.RegisterSingleton<IStatusBarProxy, StatusBarProxy>();
+
+            //
+            // Shell Common Dialog Proxy
+            //
+
+            containerRegistry.RegisterSingleton<ICommonFolderDialogProxy, CommonFolderDialogProxy>();
+            containerRegistry.RegisterSingleton<ICommonOpenLoadFileDialogProxy, CommonOpenLoadFileDialogProxy>();
+#endif
+
+            logger.Trace("RegisterTypes end");
+        }
+
+        public void OnInitialized(IContainerProvider containerProvider)
+        {
+#if false
+            //
+            // Views and ViewModels
+            //
+
+            ViewModelLocationProvider.Register<UniversalDialog>(() => containerProvider.Resolve<IUniversalDialogViewModel>());
+
+            logger.Trace("OnInitialized end");
+#endif
+        }
+
+    }
+}
\ No newline at end of file

--- /dev/null
+++ b/Core/Resource/MessageRepository.cs
@@ -0,0 +1,60 @@
+using CleanAuLait.OuterEdge.Repository;
+using NLog;
+using System.Reflection;
+
+namespace CleanAuLait.Core.Resource
+{
+    public class MessageRepository : AbstractMessageRepository
+    {
+        private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
+
+        public MessageRepository(string resourcePathPrefix, string resourceRelativePath) :
+                this(resourcePathPrefix, resourceRelativePath, null)
+        {
+        }
+
+        public MessageRepository(string resourcePathPrefix, string resourceRelativePath, Assembly asm)
+        {
+            ReadMessageFromResource(resourcePathPrefix, resourceRelativePath, asm);
+        }
+
+        public MessageRepository(string resourcePathPrefix)
+        {
+            ReadMessageFromAsset(resourcePathPrefix);
+        }
+
+        private async void ReadMessageFromResource(string resourcePathPrefix, string resourceRelativePath, Assembly asm)
+        {
+            string content = await ResourceHelper.LoadTextFromResourceAsync(resourcePathPrefix, resourceRelativePath, asm)
+            .ContinueWith(t =>
+            {
+                if (t.Exception != null)
+                {
+                    logger.Error(t.Exception);
+                    throw new RepositoryException(t.Exception);
+                }
+
+                return t.Result;
+            });
+
+            RegisterMessages(content);
+        }
+
+        private async void ReadMessageFromAsset(string resourcePathPrefix)
+        {
+            string content = await ResourceHelper.LoadTextFromAssetAsync(null, resourcePathPrefix)
+            .ContinueWith(t =>
+            {
+                if (t.Exception != null)
+                {
+                    logger.Error(t.Exception);
+                    throw new RepositoryException(t.Exception);
+                }
+
+                return t.Result;
+            });
+
+            RegisterMessages(content);
+        }
+    }
+}

--- /dev/null
+++ b/Core/Resource/ResourceHelper.cs
@@ -0,0 +1,128 @@
+using Microsoft.UI.Xaml.Media.Imaging;
+using NLog;
+using System.Reflection;
+using Windows.Storage;
+
+namespace CleanAuLait.Core.Resource
+{
+    public static class ResourceHelper
+    {
+        private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
+
+        public static async Task<string> LoadTextFromAssetAsync(string resourcePathPrefix, string resourceRelativePath)
+        {
+            Uri resourceUri = CreateAssetUri(resourcePathPrefix, resourceRelativePath);
+
+            return await LoadTextFromUriAsync(resourceUri);
+        }
+
+
+        public static async Task<string> LoadTextFromResourceAsync(string resourcePathPrefix, string resourceRelativePath, Assembly assembly = null)
+        {
+            Uri resourceUri = CreateResourceUri(assembly, resourcePathPrefix, resourceRelativePath);
+
+            return await LoadTextFromUriAsync(resourceUri);
+        }
+
+        private static async Task<string> LoadTextFromUriAsync(Uri resourceUri)
+        {
+            try
+            {
+                var file = await StorageFile.GetFileFromApplicationUriAsync(resourceUri).AsTask().ConfigureAwait(false);
+                var content = await FileIO.ReadTextAsync(file).AsTask().ConfigureAwait(false);
+
+                return content;
+            }
+            catch (SystemException e)
+            {
+                logger.Error(e);
+                throw new ApplicationException($"リソーステキスト {resourceUri} の読み込みに失敗しました", e);
+            }
+        }
+
+        public static BitmapImage LoadBitmapFromAsset(string resourcePathPrefix, string resourceRelativePath)
+        {
+            Uri resourceUri = CreateAssetUri(resourcePathPrefix, resourceRelativePath);
+
+            return LoadBitmapFromUri(resourceUri);
+        }
+
+        public static BitmapImage LoadBitmapFromResource(string resourcePathPrefix, string resourceRelativePath, Assembly assembly = null)
+        {
+            Uri resourceUri = CreateResourceUri(assembly, resourcePathPrefix, resourceRelativePath);
+
+            return LoadBitmapFromUri(resourceUri);
+        }
+
+        private static BitmapImage LoadBitmapFromUri(Uri resourceUri)
+        {
+            try
+            {
+                /// <see cref="https://stackoverflow.com/questions/347614/storing-wpf-image-resources"/>
+                return new BitmapImage(resourceUri);
+            }
+            catch (SystemException e)
+            {
+                logger.Error(e);
+                throw new ApplicationException($"リソース画像 {resourceUri} の読み込みに失敗しました", e);
+            }
+        }
+
+        private static Uri CreateAssetUri(string resourcePathPrefix, string resourceRelativePath)
+        {
+            string resourcePath = CreateResourcePath(resourcePathPrefix, resourceRelativePath);
+
+            Uri resourceUri = CreateAssetUri(resourcePath);
+
+            return resourceUri;
+        }
+
+        private static Uri CreateResourceUri(Assembly assembly, string resourcePathPrefix, string resourceRelativePath)
+        {
+            if (assembly == null)
+            {
+                assembly = Assembly.GetCallingAssembly();
+            }
+
+            string assemblyName = assembly.GetName().Name;
+
+            string resourcePath = CreateResourcePath(resourcePathPrefix, resourceRelativePath);
+
+            Uri resourceUri = CreateResourceUri(assemblyName, resourcePath);
+
+            return resourceUri;
+        }
+
+        private static string CreateResourcePath(string resourcePathPrefix, string resourceRelativePath)
+        {
+            if (resourcePathPrefix == null)
+            {
+                resourcePathPrefix = String.Empty;
+            }
+
+            if (resourcePathPrefix.StartsWith("/"))
+            {
+                resourcePathPrefix = resourcePathPrefix[1..];
+            }
+
+            string resourcePath = resourcePathPrefix + resourceRelativePath;
+            return resourcePath;
+        }
+
+        private static Uri CreateAssetUri(string resourcePath)
+        {
+            string resourceUriPath = string.Format(@"ms-appx:///Assets/{0}", resourcePath);
+            Uri resourceUri = new(resourceUriPath, UriKind.Absolute);
+
+            return resourceUri;
+        }
+
+        private static Uri CreateResourceUri(string assemblyName, string resourcePath)
+        {
+            string resourceUriPath = string.Format(@"pack://application:,,,/{0};component/{1}", assemblyName, resourcePath);
+            Uri resourceUri = new(resourceUriPath, UriKind.Absolute);
+
+            return resourceUri;
+        }
+    }
+}

--- /dev/null
+++ b/Gateway/UI/Dialog/UserDialogProxy.cs
@@ -0,0 +1,66 @@
+using CleanAuLait.Adaptor.Boundary.Gateway.UI.Dialog;
+using CleanAuLait.Core.Resource;
+using System.Windows;
+
+namespace CleanAuLait.Adaptor.Gateway.UI.Dialog
+{
+    public class UserDialogProxy : IUserDialogProxy
+    {
+        private readonly ICaptionFormatter captionFormatter;
+
+        public UserDialogProxy(
+            ICaptionFormatter captionFormatter)
+        {
+            this.captionFormatter = captionFormatter;
+        }
+
+        public void ShowInfo(string msg)
+        {
+            ShowInfo(msg, null);
+        }
+
+        public void ShowInfo(string msg, string caption)
+        {
+            string infoCaption = captionFormatter.GetInfoCaption(caption);
+            ShowNotify(infoCaption, msg);
+        }
+
+        public void ShowWarn(string msg)
+        {
+            ShowWarn(msg, null);
+        }
+
+        public void ShowWarn(string msg, string caption)
+        {
+            string warnCaption = captionFormatter.GetWarnCaption(caption);
+            ShowNotify(warnCaption, msg);
+        }
+
+        public void ShowError(Exception e)
+        {
+            ShowError(e, null);
+        }
+
+        public void ShowError(Exception e, string caption)
+        {
+            string errorCaption = captionFormatter.GetExceptionCaption(e, caption);
+            ShowNotify(errorCaption, e.Message);
+        }
+
+        public void ShowError(string msg)
+        {
+            ShowError(msg, null);
+        }
+
+        public void ShowError(string msg, string caption)
+        {
+            string errorCaption = captionFormatter.GetErrorCaption(caption);
+            ShowNotify(errorCaption, msg);
+        }
+
+        public void ShowNotify(string caption, string msg)
+        {
+            MessageBox.Show(msg, caption);
+        }
+    }
+}