Commit: 3efb8167194b572d6c1931e2dedd2a4e2a2bddf2 - FolderCategorizer2 (git)

ファイル整理用ツールのPrism+WPFサンプル実装

Commit MetaInfo

• Revisão: 3efb8167194b572d6c1931e2dedd2a4e2a2bddf2 (tree)
• Hora: 2023-09-24 14:20:43
• Autor: yoshy <yoshy.org.bitbucket@gz.j...>
• Commiter: yoshy

Mensagem de Log

[MOD] ファイルシステム操作系インタラクタ・ロジック処理上で行っていたフォルダツリーの更新処理をプレゼンタに移譲

Mudança Sumário

• add: FolderCategorizer2.02UseCase/Boundary/FileSystemOperation/Presenter/IFileSystemCopyOperationPresenter.cs
• add: FolderCategorizer2.02UseCase/Boundary/FileSystemOperation/Presenter/IFileSystemMoveOperationPresenter.cs
• modified: FolderCategorizer2.02UseCase/FileSystemOperation/Interactor/FileSystemCopyOperationInteractor.cs
• modified: FolderCategorizer2.02UseCase/FileSystemOperation/Interactor/FileSystemMoveOperationInteractor.cs
• modified: FolderCategorizer2.02UseCase/FileSystemOperation/Response/FileSystemCopyOperationResponse.cs
• modified: FolderCategorizer2.02UseCase/FileSystemOperation/Response/FileSystemMoveOperationResponse.cs
• modified: FolderCategorizer2.02UseCase/Internal/FileSystemOperationLogic.cs
• modified: FolderCategorizer2.03Adaptor/AdaptorModule.cs
• add: FolderCategorizer2.03Adaptor/Presenter/FileSystemCopyOperationPresenter.cs
• modified: FolderCategorizer2.03Adaptor/Presenter/FileSystemDeleteOperationPresenter.cs
• add: FolderCategorizer2.03Adaptor/Presenter/FileSystemMoveOperationPresenter.cs
• modified: FolderCategorizer2.03Adaptor/Presenter/FileSystemNewFileOperationPresenter.cs
• modified: FolderCategorizer2.03Adaptor/Presenter/FileSystemNewFolderOperationPresenter.cs
• modified: FolderCategorizer2.03Adaptor/Presenter/FileSystemRenameOperationPresenter.cs
• modified: FolderCategorizer2.04OuterEdge/Repository/OS/LocalFileSystemRepository.cs
• modified: FolderCategorizer2.05Infra/FolderCategorizer2.05Infra.csproj

Diff

--- /dev/null
+++ b/FolderCategorizer2.02UseCase/Boundary/FileSystemOperation/Presenter/IFileSystemCopyOperationPresenter.cs
@@ -0,0 +1,11 @@
+using CleanAuLait.UseCase.Boundary.Presenter;
+using FolderCategorizer2.UseCase.FileSystemOperation.Request;
+using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+
+namespace FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter
+{
+    public interface IFileSystemCopyOperationPresenter
+            : IPresenter<FileSystemCopyOperationRequest, FileSystemCopyOperationResponse>
+    {
+    }
+}
\ No newline at end of file

--- /dev/null
+++ b/FolderCategorizer2.02UseCase/Boundary/FileSystemOperation/Presenter/IFileSystemMoveOperationPresenter.cs
@@ -0,0 +1,11 @@
+using CleanAuLait.UseCase.Boundary.Presenter;
+using FolderCategorizer2.UseCase.FileSystemOperation.Request;
+using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+
+namespace FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter
+{
+    public interface IFileSystemMoveOperationPresenter
+            : IPresenter<FileSystemMoveOperationRequest, FileSystemMoveOperationResponse>
+    {
+    }
+}
\ No newline at end of file

--- a/FolderCategorizer2.02UseCase/FileSystemOperation/Interactor/FileSystemCopyOperationInteractor.cs
+++ b/FolderCategorizer2.02UseCase/FileSystemOperation/Interactor/FileSystemCopyOperationInteractor.cs
@@ -1,13 +1,12 @@
 using CleanAuLait.UseCase.Interactor;
 using CleanAuLait.UseCase.Response;
-using FolderCategorizer2.Domain.Boundary.Service;
 using FolderCategorizer2.Domain.Service.Dto;
+using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
 using FolderCategorizer2.UseCase.Boundary.FileSystemOperation.Interactor;
 using FolderCategorizer2.UseCase.FileSystemOperation.Request;
 using FolderCategorizer2.UseCase.FileSystemOperation.Response;
 using FolderCategorizer2.UseCase.Internal;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace FolderCategorizer2.UseCase.FileSystemOperation.Interactor
 {
@@ -20,18 +19,18 @@ namespace FolderCategorizer2.UseCase.FileSystemOperation.Interactor
         private readonly IFileSystemOperationLogic operation;
         private readonly IFileSystemVerifyLogic verifier;
         private readonly IFileSystemDialogLogic dialog;
-        private readonly IFolderTreeService folderTree;
+        private readonly IFileSystemCopyOperationPresenter presenter;
 
         public FileSystemCopyOperationInteractor(
                 IFileSystemOperationLogic operation,
                 IFileSystemVerifyLogic verifier,
                 IFileSystemDialogLogic dialog,
-                IFolderTreeService folderTree)
+                IFileSystemCopyOperationPresenter presenter)
         {
             this.operation = operation;
             this.verifier = verifier;
             this.dialog = dialog;
-            this.folderTree = folderTree;
+            this.presenter = presenter;
         }
 
         public override FileSystemCopyOperationResponse Interact(FileSystemCopyOperationRequest req)
@@ -65,18 +64,10 @@ namespace FolderCategorizer2.UseCase.FileSystemOperation.Interactor
                 return UseCaseResponse.Abort<FileSystemCopyOperationResponse>("エラーのため処理が中止されました");
             }
 
-            SelectNode(sourceTargetEntries);
+            FileSystemCopyOperationResponse res = new(sourceTargetEntries);
 
-            return new();
+            return this.presenter.Present(req, res);
         }
 
-        private void SelectNode(IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries)
-        {
-            FileSystemSourceFilesTargetFolder sourceTargetEntry = sourceTargetEntries.First();
-
-            string treeId = sourceTargetEntry.TreeID;
-
-            this.folderTree.SelectNode(treeId, sourceTargetEntry.TargetFolder.RelativePath);
-        }
     }
 }

--- a/FolderCategorizer2.02UseCase/FileSystemOperation/Interactor/FileSystemMoveOperationInteractor.cs
+++ b/FolderCategorizer2.02UseCase/FileSystemOperation/Interactor/FileSystemMoveOperationInteractor.cs
@@ -1,13 +1,12 @@
 using CleanAuLait.UseCase.Interactor;
 using CleanAuLait.UseCase.Response;
-using FolderCategorizer2.Domain.Boundary.Service;
 using FolderCategorizer2.Domain.Service.Dto;
+using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
 using FolderCategorizer2.UseCase.Boundary.FileSystemOperation.Interactor;
 using FolderCategorizer2.UseCase.FileSystemOperation.Request;
 using FolderCategorizer2.UseCase.FileSystemOperation.Response;
 using FolderCategorizer2.UseCase.Internal;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace FolderCategorizer2.UseCase.FileSystemOperation.Interactor
 {
@@ -20,18 +19,18 @@ namespace FolderCategorizer2.UseCase.FileSystemOperation.Interactor
         private readonly IFileSystemOperationLogic operation;
         private readonly IFileSystemVerifyLogic verifier;
         private readonly IFileSystemDialogLogic dialog;
-        private readonly IFolderTreeService folderTree;
+        private readonly IFileSystemMoveOperationPresenter presenter;
 
         public FileSystemMoveOperationInteractor(
                 IFileSystemOperationLogic operation,
                 IFileSystemVerifyLogic verifier,
                 IFileSystemDialogLogic dialog,
-                IFolderTreeService folderTree)
+                IFileSystemMoveOperationPresenter presenter)
         {
             this.operation = operation;
             this.verifier = verifier;
             this.dialog = dialog;
-            this.folderTree = folderTree;
+            this.presenter = presenter;
         }
 
         public override FileSystemMoveOperationResponse Interact(FileSystemMoveOperationRequest req)
@@ -65,21 +64,9 @@ namespace FolderCategorizer2.UseCase.FileSystemOperation.Interactor
                 return UseCaseResponse.Abort<FileSystemMoveOperationResponse>("エラーのため処理が中止されました");
             }
 
-            SelectNode(sourceTargetEntries);
+            FileSystemMoveOperationResponse res = new(sourceTargetEntries);
 
-            return new();
+            return this.presenter.Present(req, res);
         }
-
-        private void SelectNode(IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries)
-        {
-            // FIX ME
-
-            FileSystemSourceFilesTargetFolder sourceTargetEntry = sourceTargetEntries.First();
-
-            string treeId = sourceTargetEntry.TreeID;
-
-            this.folderTree.SelectNode(treeId, sourceTargetEntry.TargetFolder.RelativePath);
-        }
-
     }
 }

--- a/FolderCategorizer2.02UseCase/FileSystemOperation/Response/FileSystemCopyOperationResponse.cs
+++ b/FolderCategorizer2.02UseCase/FileSystemOperation/Response/FileSystemCopyOperationResponse.cs
@@ -1,8 +1,16 @@
 using CleanAuLait.UseCase.Response;
+using FolderCategorizer2.Domain.Service.Dto;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace FolderCategorizer2.UseCase.FileSystemOperation.Response
 {
-    public record class FileSystemCopyOperationResponse : UseCaseResponse
+    public record class FileSystemCopyOperationResponse(
+            IEnumerable<FileSystemSourceFilesTargetFolder> SourceTargetEntries) : UseCaseResponse
     {
+        public FileSystemCopyOperationResponse() : this(
+                Enumerable.Empty<FileSystemSourceFilesTargetFolder>())
+        {
+        }
     }
 }

--- a/FolderCategorizer2.02UseCase/FileSystemOperation/Response/FileSystemMoveOperationResponse.cs
+++ b/FolderCategorizer2.02UseCase/FileSystemOperation/Response/FileSystemMoveOperationResponse.cs
@@ -1,8 +1,16 @@
 using CleanAuLait.UseCase.Response;
+using FolderCategorizer2.Domain.Service.Dto;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace FolderCategorizer2.UseCase.FileSystemOperation.Response
 {
-    public record class FileSystemMoveOperationResponse : UseCaseResponse
+    public record class FileSystemMoveOperationResponse(
+            IEnumerable<FileSystemSourceFilesTargetFolder> SourceTargetEntries) : UseCaseResponse
     {
+        public FileSystemMoveOperationResponse() : this(
+                Enumerable.Empty<FileSystemSourceFilesTargetFolder>())
+        {
+        }
     }
 }

--- a/FolderCategorizer2.02UseCase/Internal/FileSystemOperationLogic.cs
+++ b/FolderCategorizer2.02UseCase/Internal/FileSystemOperationLogic.cs
@@ -16,16 +16,13 @@ namespace FolderCategorizer2.UseCase.Internal
         private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
 
         private readonly IFileSystemService fileSystem;
-        private readonly IFolderTreeService folderTree;
         private readonly IUniversalDialogProxy dialog;
 
         public FileSystemOperationLogic(
                 IFileSystemService fileSystem,
-                IFolderTreeService folderTree,
                 IUniversalDialogProxy dialog)
         {
             this.fileSystem = fileSystem;
-            this.folderTree = folderTree;
             this.dialog = dialog;
         }
 
@@ -41,6 +38,9 @@ namespace FolderCategorizer2.UseCase.Internal
                     string sourceFullPath = PathHelper.CreateCanonicalPath(sourceFolderPath, name);
                     string targetFullPath = PathHelper.CreateCanonicalPath(targetFolderPath, name);
 
+                    logger.Trace("copy: from {0}", sourceFullPath);
+                    logger.Trace("copy: to {0}", targetFullPath);
+
                 Retry:
                     try
                     {
@@ -65,12 +65,9 @@ namespace FolderCategorizer2.UseCase.Internal
                                 return false;
                         }
                     }
-                }
 
-                string treeId = sourceTargetEntry.TreeID;
-
-                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.SourceFiles.RelativePath);
-                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.TargetFolder.RelativePath);
+                    logger.Trace("copied.");
+                }
             }
 
             return true;
@@ -88,6 +85,9 @@ namespace FolderCategorizer2.UseCase.Internal
                     string sourceFullPath = PathHelper.CreateCanonicalPath(sourceFolderPath, name);
                     string targetFullPath = PathHelper.CreateCanonicalPath(targetFolderPath, name);
 
+                    logger.Trace("move: from {0}", sourceFullPath);
+                    logger.Trace("move: to {0}", targetFullPath);
+
                 Retry:
                     try
                     {
@@ -112,12 +112,9 @@ namespace FolderCategorizer2.UseCase.Internal
                                 return false;
                         }
                     }
-                }
 
-                string treeId = sourceTargetEntry.TreeID;
-
-                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.SourceFiles.RelativePath);
-                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.TargetFolder.RelativePath);
+                    logger.Trace("moved.");
+                }
             }
 
             return true;
@@ -141,7 +138,7 @@ namespace FolderCategorizer2.UseCase.Internal
                     catch (Exception e) when (e is IOException || e is InvalidOperationException)
                     {
                         string msg = string.Format(
-                                "ファイルのコピー中に次のエラーが発生しました。\n{0}\n\n削除対象：{1}",
+                                "ファイルの削除中に次のエラーが発生しました。\n{0}\n\n削除対象：{1}",
                                 e.Message, sourceFullPath);
 
                         IDialogResult result = this.dialog.ShowAbortRetryIgnoreDialog("ファイルの削除 - エラー", msg, MessageBoxImage.Hand);
@@ -158,10 +155,6 @@ namespace FolderCategorizer2.UseCase.Internal
                         }
                     }
                 }
-
-                string treeId = sourceFiles.TreeID;
-
-                this.folderTree.RefreshFolderTree(treeId, sourceFiles.RelativePath);
             }
 
             return true;
@@ -197,10 +190,6 @@ namespace FolderCategorizer2.UseCase.Internal
                             return false;
                     }
                 }
-
-                string treeId = targetEntry.TreeID;
-
-                this.folderTree.RefreshFolderTree(treeId, targetEntry.RelativePath);
             }
 
             return true;
@@ -236,10 +225,6 @@ namespace FolderCategorizer2.UseCase.Internal
                             return false;
                     }
                 }
-
-                string treeId = targetEntry.TreeID;
-
-                this.folderTree.RefreshFolderTree(treeId, targetEntry.RelativePath);
             }
 
             return true;
@@ -276,10 +261,6 @@ namespace FolderCategorizer2.UseCase.Internal
                             return false;
                     }
                 }
-
-                string treeId = sourceFile.TreeID;
-
-                this.folderTree.RefreshFolderTree(treeId, sourceFile.RelativePath);
             }
 
             return true;

--- a/FolderCategorizer2.03Adaptor/AdaptorModule.cs
+++ b/FolderCategorizer2.03Adaptor/AdaptorModule.cs
@@ -102,6 +102,8 @@ namespace FolderCategorizer2.Adaptor
             containerRegistry.RegisterSingleton<IFolderTreeReplaceTreePresenter, FolderTreeReplaceTreePresenter>();
             containerRegistry.RegisterSingleton<IFileListReplaceListPresenter, FileListReplaceListPresenter>();
 
+            containerRegistry.RegisterSingleton<IFileSystemCopyOperationPresenter, FileSystemCopyOperationPresenter>();
+            containerRegistry.RegisterSingleton<IFileSystemMoveOperationPresenter, FileSystemMoveOperationPresenter>();
             containerRegistry.RegisterSingleton<IFileSystemDeleteOperationPresenter, FileSystemDeleteOperationPresenter>();
             containerRegistry.RegisterSingleton<IFileSystemRenameOperationPresenter, FileSystemRenameOperationPresenter>();
             containerRegistry.RegisterSingleton<IFileSystemNewFolderOperationPresenter, FileSystemNewFolderOperationPresenter>();

--- /dev/null
+++ b/FolderCategorizer2.03Adaptor/Presenter/FileSystemCopyOperationPresenter.cs
@@ -0,0 +1,51 @@
+using FolderCategorizer2.Domain.Boundary.Service;
+using FolderCategorizer2.Domain.Service.Dto;
+using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
+using FolderCategorizer2.UseCase.FileSystemOperation.Request;
+using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FolderCategorizer2.Adaptor.Presenter
+{
+    public class FileSystemCopyOperationPresenter : IFileSystemCopyOperationPresenter
+    {
+        private readonly IFolderTreeService folderTree;
+
+        public FileSystemCopyOperationPresenter(IFolderTreeService folderTree)
+        {
+            this.folderTree = folderTree;
+        }
+
+        public FileSystemCopyOperationResponse Present(
+                FileSystemCopyOperationRequest req, FileSystemCopyOperationResponse res)
+        {
+            IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries = res.SourceTargetEntries;
+
+            RefreshNodes(sourceTargetEntries);
+            SelectNode(sourceTargetEntries);
+
+            return res;
+        }
+
+        private void RefreshNodes(IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries)
+        {
+            foreach (FileSystemSourceFilesTargetFolder sourceTargetEntry in sourceTargetEntries)
+            {
+                string treeId = sourceTargetEntry.TreeID;
+
+                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.SourceFiles.RelativePath);
+                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.TargetFolder.RelativePath);
+            }
+        }
+
+        private void SelectNode(IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries)
+        {
+            FileSystemSourceFilesTargetFolder sourceTargetEntry = sourceTargetEntries.First();
+
+            string treeId = sourceTargetEntry.TreeID;
+
+            this.folderTree.SelectNode(treeId, sourceTargetEntry.TargetFolder.RelativePath);
+        }
+    }
+}

--- a/FolderCategorizer2.03Adaptor/Presenter/FileSystemDeleteOperationPresenter.cs
+++ b/FolderCategorizer2.03Adaptor/Presenter/FileSystemDeleteOperationPresenter.cs
@@ -1,25 +1,44 @@
 using FolderCategorizer2.Adaptor.Boundary.ViewModel;
+using FolderCategorizer2.Domain.Boundary.Service;
+using FolderCategorizer2.Domain.Service.Dto;
 using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
 using FolderCategorizer2.UseCase.FileSystemOperation.Request;
 using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+using System.Collections.Generic;
 
 namespace FolderCategorizer2.Adaptor.Presenter
 {
     public class FileSystemDeleteOperationPresenter : IFileSystemDeleteOperationPresenter
     {
+        private readonly IFolderTreeService folderTree;
         private readonly IFileListViewModel targetVm;
 
-        public FileSystemDeleteOperationPresenter(IFileListViewModel targetVm)
+        public FileSystemDeleteOperationPresenter(
+                IFolderTreeService folderTree,
+                IFileListViewModel targetVm)
         {
+            this.folderTree = folderTree;
             this.targetVm = targetVm;
         }
 
         public FileSystemDeleteOperationResponse Present(
                 FileSystemDeleteOperationRequest req, FileSystemDeleteOperationResponse res)
         {
+            RefreshNodes(req.SourceFilesList);
+
             this.targetVm.ReplaceSource(res.Diff);
 
             return res;
         }
+
+        private void RefreshNodes(IEnumerable<FileSystemSourceFiles> sourceFileList)
+        {
+            foreach (FileSystemSourceFiles sourceFiles in sourceFileList)
+            {
+                string treeId = sourceFiles.TreeID;
+
+                this.folderTree.RefreshFolderTree(treeId, sourceFiles.RelativePath);
+            }
+        }
     }
 }

--- /dev/null
+++ b/FolderCategorizer2.03Adaptor/Presenter/FileSystemMoveOperationPresenter.cs
@@ -0,0 +1,53 @@
+using FolderCategorizer2.Domain.Boundary.Service;
+using FolderCategorizer2.Domain.Service.Dto;
+using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
+using FolderCategorizer2.UseCase.FileSystemOperation.Request;
+using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FolderCategorizer2.Adaptor.Presenter
+{
+    public class FileSystemMoveOperationPresenter : IFileSystemMoveOperationPresenter
+    {
+        private readonly IFolderTreeService folderTree;
+
+        public FileSystemMoveOperationPresenter(IFolderTreeService folderTree)
+        {
+            this.folderTree = folderTree;
+        }
+
+        public FileSystemMoveOperationResponse Present(
+                FileSystemMoveOperationRequest req, FileSystemMoveOperationResponse res)
+        {
+            IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries = res.SourceTargetEntries;
+
+            RefreshNodes(sourceTargetEntries);
+
+            // FIX ME: freeze screen
+            //SelectNode(sourceTargetEntries);
+
+            return res;
+        }
+
+        private void RefreshNodes(IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries)
+        {
+            foreach (FileSystemSourceFilesTargetFolder sourceTargetEntry in sourceTargetEntries)
+            {
+                string treeId = sourceTargetEntry.TreeID;
+
+                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.SourceFiles.RelativePath);
+                this.folderTree.RefreshFolderTree(treeId, sourceTargetEntry.TargetFolder.RelativePath);
+            }
+        }
+
+        private void SelectNode(IEnumerable<FileSystemSourceFilesTargetFolder> sourceTargetEntries)
+        {
+            FileSystemSourceFilesTargetFolder sourceTargetEntry = sourceTargetEntries.First();
+
+            string treeId = sourceTargetEntry.TreeID;
+
+            this.folderTree.SelectNode(treeId, sourceTargetEntry.TargetFolder.RelativePath);
+        }
+    }
+}

--- a/FolderCategorizer2.03Adaptor/Presenter/FileSystemNewFileOperationPresenter.cs
+++ b/FolderCategorizer2.03Adaptor/Presenter/FileSystemNewFileOperationPresenter.cs
@@ -1,25 +1,44 @@
 using FolderCategorizer2.Adaptor.Boundary.ViewModel;
+using FolderCategorizer2.Domain.Boundary.Service;
+using FolderCategorizer2.Domain.Service.Dto;
 using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
 using FolderCategorizer2.UseCase.FileSystemOperation.Request;
 using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+using System.Collections.Generic;
 
 namespace FolderCategorizer2.Adaptor.Presenter
 {
     public class FileSystemNewFileOperationPresenter : IFileSystemNewFileOperationPresenter
     {
+        private readonly IFolderTreeService folderTree;
         private readonly IFileListViewModel targetVm;
 
-        public FileSystemNewFileOperationPresenter(IFileListViewModel targetVm)
+        public FileSystemNewFileOperationPresenter(
+                IFolderTreeService folderTree,
+                IFileListViewModel targetVm)
         {
+            this.folderTree = folderTree;
             this.targetVm = targetVm;
         }
 
         public FileSystemNewFileOperationResponse Present(
                 FileSystemNewFileOperationRequest req, FileSystemNewFileOperationResponse res)
         {
+            RefreshNodes(req.Targets);
+
             this.targetVm.ReplaceSource(res.Diff);
 
             return res;
         }
+
+        private void RefreshNodes(IEnumerable<FileSystemPathEntry> targetEntries)
+        {
+            foreach (FileSystemPathEntry targetEntry in targetEntries)
+            {
+                string treeId = targetEntry.TreeID;
+
+                this.folderTree.RefreshFolderTree(treeId, targetEntry.RelativePath);
+            }
+        }
     }
 }

--- a/FolderCategorizer2.03Adaptor/Presenter/FileSystemNewFolderOperationPresenter.cs
+++ b/FolderCategorizer2.03Adaptor/Presenter/FileSystemNewFolderOperationPresenter.cs
@@ -1,25 +1,44 @@
 using FolderCategorizer2.Adaptor.Boundary.ViewModel;
+using FolderCategorizer2.Domain.Boundary.Service;
+using FolderCategorizer2.Domain.Service.Dto;
 using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
 using FolderCategorizer2.UseCase.FileSystemOperation.Request;
 using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+using System.Collections.Generic;
 
 namespace FolderCategorizer2.Adaptor.Presenter
 {
     public class FileSystemNewFolderOperationPresenter : IFileSystemNewFolderOperationPresenter
     {
+        private readonly IFolderTreeService folderTree;
         private readonly IFileListViewModel targetVm;
 
-        public FileSystemNewFolderOperationPresenter(IFileListViewModel targetVm)
+        public FileSystemNewFolderOperationPresenter(
+                IFolderTreeService folderTree,
+                IFileListViewModel targetVm)
         {
+            this.folderTree = folderTree;
             this.targetVm = targetVm;
         }
 
         public FileSystemNewFolderOperationResponse Present(
                 FileSystemNewFolderOperationRequest req, FileSystemNewFolderOperationResponse res)
         {
+            RefreshNodes(req.Targets);
+
             this.targetVm.ReplaceSource(res.Diff);
 
             return res;
         }
+
+        private void RefreshNodes(IEnumerable<FileSystemPathEntry> targetEntries)
+        {
+            foreach (FileSystemPathEntry targetEntry in targetEntries)
+            {
+                string treeId = targetEntry.TreeID;
+
+                this.folderTree.RefreshFolderTree(treeId, targetEntry.RelativePath);
+            }
+        }
     }
 }

--- a/FolderCategorizer2.03Adaptor/Presenter/FileSystemRenameOperationPresenter.cs
+++ b/FolderCategorizer2.03Adaptor/Presenter/FileSystemRenameOperationPresenter.cs
@@ -1,25 +1,44 @@
 using FolderCategorizer2.Adaptor.Boundary.ViewModel;
+using FolderCategorizer2.Domain.Boundary.Service;
+using FolderCategorizer2.Domain.Service.Dto;
 using FolderCategorizer2.UseCase.Boundary.FileListOperation.Presenter;
 using FolderCategorizer2.UseCase.FileSystemOperation.Request;
 using FolderCategorizer2.UseCase.FileSystemOperation.Response;
+using System.Collections.Generic;
 
 namespace FolderCategorizer2.Adaptor.Presenter
 {
     public class FileSystemRenameOperationPresenter : IFileSystemRenameOperationPresenter
     {
+        private readonly IFolderTreeService folderTree;
         private readonly IFileListViewModel targetVm;
 
-        public FileSystemRenameOperationPresenter(IFileListViewModel targetVm)
+        public FileSystemRenameOperationPresenter(
+                IFolderTreeService folderTree,
+                IFileListViewModel targetVm)
         {
+            this.folderTree = folderTree;
             this.targetVm = targetVm;
         }
 
         public FileSystemRenameOperationResponse Present(
                 FileSystemRenameOperationRequest req, FileSystemRenameOperationResponse res)
         {
+            RefreshNodes(req.SourceFileList);
+
             this.targetVm.ReplaceSource(res.Diff);
 
             return res;
         }
+
+        private void RefreshNodes(IEnumerable<FileSystemSourceFile> sourceFileList)
+        {
+            foreach (FileSystemSourceFile sourceFile in sourceFileList)
+            {
+                string treeId = sourceFile.TreeID;
+
+                this.folderTree.RefreshFolderTree(treeId, sourceFile.RelativePath);
+            }
+        }
     }
 }

--- a/FolderCategorizer2.04OuterEdge/Repository/OS/LocalFileSystemRepository.cs
+++ b/FolderCategorizer2.04OuterEdge/Repository/OS/LocalFileSystemRepository.cs
@@ -1,4 +1,5 @@
-using FolderCategorizer2.Domain.Boundary.Repository;
+using CleanAuLait.Core.IO;
+using FolderCategorizer2.Domain.Boundary.Repository;
 using FolderCategorizer2.Domain.Model.Const;
 using FolderCategorizer2.Domain.Service.Dto;
 using FolderCategorizer2.OuterEdge.Translator;
@@ -108,69 +109,160 @@ namespace FolderCategorizer2.OuterEdge.Repository.OS
 
         public void MoveFile(string targetPath, string sourceFullPath)
         {
+#if false
             if (Directory.Exists(sourceFullPath))
             {
                 logger.Debug("FileSystem.MoveDirectory({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.MoveDirectory(sourceFullPath, targetPath);
+                VBFileSystem.MoveDirectory(sourceFullPath, targetPath, UIOption.AllDialogs);
             }
             else if (File.Exists(sourceFullPath))
             {
                 logger.Debug("FileSystem.MoveFile({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.MoveFile(sourceFullPath, targetPath);
+                VBFileSystem.MoveFile(sourceFullPath, targetPath, UIOption.AllDialogs);
             }
             else
             {
                 throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
             }
+#else
+            if (Directory.Exists(sourceFullPath))
+            {
+                logger.Debug("Directory.Move({0}, {1})", sourceFullPath, targetPath);
+                Directory.Move(sourceFullPath, targetPath);
+            }
+            else if (File.Exists(sourceFullPath))
+            {
+                logger.Debug("File.Move({0}, {1})", sourceFullPath, targetPath);
+                File.Move(sourceFullPath, targetPath);
+            }
+            else
+            {
+                throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
+            }
+#endif
         }
 
         public void CopyFile(string targetPath, string sourceFullPath)
         {
+#if false
             if (Directory.Exists(sourceFullPath))
             {
                 logger.Debug("FileSystem.CopyDirectory({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.CopyDirectory(sourceFullPath, targetPath);
+                VBFileSystem.CopyDirectory(sourceFullPath, targetPath, UIOption.AllDialogs);
             }
             else if (File.Exists(sourceFullPath))
             {
                 logger.Debug("FileSystem.CopyFile({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.CopyFile(sourceFullPath, targetPath);
+                VBFileSystem.CopyFile(sourceFullPath, targetPath, UIOption.AllDialogs);
             }
             else
             {
                 throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
             }
+#else
+           if (Directory.Exists(sourceFullPath))
+            {
+                //logger.Debug("Directory.Copy({0}, {1})", sourceFullPath, targetPath);
+                CopyDirectory(targetPath, sourceFullPath);
+            }
+            else if (File.Exists(sourceFullPath))
+            {
+                logger.Debug("File.Copy({0}, {1})", sourceFullPath, targetPath);
+                File.Copy(sourceFullPath, targetPath);
+            }
+            else
+            {
+                throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
+            }
+#endif
+        }
+
+        /// <see cref="https://learn.microsoft.com/ja-jp/dotnet/standard/io/how-to-copy-directories"/>
+        private void CopyDirectory(string targetPath, string sourceFullPath)
+        {
+            // Get information about the source directory
+            DirectoryInfo dir = new(sourceFullPath);
+
+            // Check if the source directory exists
+            if (!dir.Exists)
+                throw new DirectoryNotFoundException($"Source directory not found: {dir.FullName}");
+
+            // Cache directories before we start copying
+            DirectoryInfo[] dirs = dir.GetDirectories();
+
+            // Create the destination directory
+            logger.Debug("Directory.CreateDirectory({0})", targetPath);
+            Directory.CreateDirectory(targetPath);
+
+            // Get the files in the source directory and copy to the destination directory
+            foreach (FileInfo file in dir.GetFiles())
+            {
+                string targetFilePath = Path.Combine(targetPath, file.Name);
+                logger.Debug("FileInfo({0}).CopyTo({1})", file.FullName, targetFilePath);
+                file.CopyTo(targetFilePath);
+            }
+
+            // Recursively call this method
+            foreach (DirectoryInfo subDir in dirs)
+            {
+                string newDestinationDir = Path.Combine(targetPath, subDir.Name);
+                CopyDirectory(newDestinationDir, subDir.FullName);
+            }
         }
 
         public void DeleteFile(string sourceFullPath)
         {
+#if false
             if (Directory.Exists(sourceFullPath))
             {
                 logger.Debug("FileSystem.DeleteDirectory({0})", sourceFullPath);
-                VBFileSystem.DeleteDirectory(sourceFullPath, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin);
+                VBFileSystem.DeleteDirectory(sourceFullPath, UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
             }
             else if (File.Exists(sourceFullPath))
             {
                 logger.Debug("FileSystem.DeleteFile({0})", sourceFullPath);
-                VBFileSystem.DeleteFile(sourceFullPath, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin);
+                VBFileSystem.DeleteFile(sourceFullPath, UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
+            }
+            else
+            {
+                throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
+            }
+#else
+            if (Directory.Exists(sourceFullPath))
+            {
+                logger.Debug("Directory.Delete({0})", sourceFullPath);
+                Directory.Delete(sourceFullPath, true);
+            }
+            else if (File.Exists(sourceFullPath))
+            {
+                logger.Debug("File.Delete({0})", sourceFullPath);
+                File.Delete(sourceFullPath);
             }
             else
             {
                 throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
             }
+#endif
         }
 
         public void RenameFile(string sourceFullPath, string targetName)
         {
+
             if (Directory.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.RenameDirectory({0}, {1})", sourceFullPath, targetName);
-                VBFileSystem.RenameDirectory(sourceFullPath, targetName);
+                DirectoryInfo di = new(sourceFullPath);
+                string targetFullPath = PathHelper.CreateCanonicalRelativePath(di.Parent.FullName, targetName);
+
+                logger.Debug("Directory.Move({0}, {1})", sourceFullPath, targetFullPath);
+                Directory.Move(sourceFullPath, targetFullPath);
             }
             else if (File.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.RenameFile({0}, {1})", sourceFullPath, targetName);
-                VBFileSystem.RenameFile(sourceFullPath, targetName);
+                DirectoryInfo di = new(sourceFullPath);
+                string targetFullPath = PathHelper.CreateCanonicalRelativePath(di.Parent.FullName, targetName);
+
+                logger.Debug("File.Move({0}, {1})", sourceFullPath, targetFullPath);
+                File.Move(sourceFullPath, targetFullPath);
             }
             else
             {

--- a/FolderCategorizer2.05Infra/FolderCategorizer2.05Infra.csproj
+++ b/FolderCategorizer2.05Infra/FolderCategorizer2.05Infra.csproj
@@ -14,13 +14,12 @@
     <None Remove="Resources\message.properties" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="AutoMapper" Version="12.0.0" />
-    <PackageReference Include="gong-wpf-dragdrop" Version="3.2.0" />
-    <PackageReference Include="NLog" Version="5.0.4" />
+    <PackageReference Include="AutoMapper" Version="12.0.1" />
+    <PackageReference Include="gong-wpf-dragdrop" Version="3.2.1" />
     <PackageReference Include="Prism.Unity" Version="8.1.97" />
     <PackageReference Include="Prism.Wpf" Version="8.1.97" />
-    <PackageReference Include="ReactiveProperty" Version="8.1.2" />
-    <PackageReference Include="ReactiveProperty.WPF" Version="8.1.2" />
+    <PackageReference Include="ReactiveProperty" Version="9.3.1" />
+    <PackageReference Include="ReactiveProperty.WPF" Version="9.3.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\CleanAuLait.ObservableCollectionsMod\CleanAuLait.ObservableCollectionsMod.csproj" />