Delete command

src/Core/FileTime.Core.Abstraction/ContentAccess/IContentAccessorFactory.cs

@@ -8,4 +8,6 @@ public interface IContentAccessorFactory
     IContentReaderFactory GetContentReaderFactory(IContentProvider provider);
     IContentWriterFactory<TContentProvider> GetContentWriterFactory<TContentProvider>() where TContentProvider : IContentProvider;
     IContentWriterFactory GetContentWriterFactory(IContentProvider provider);
+    IItemDeleter GetItemDeleter(IContentProvider provider);
+    IItemDeleter<TContentProvider> GetItemDeleter<TContentProvider>() where TContentProvider : IContentProvider;
 }

src/Core/FileTime.Core.Abstraction/ContentAccess/IItemDeleter.cs

@@ -0,0 +1,13 @@
+using FileTime.Core.Models;
+
+namespace FileTime.Core.ContentAccess;
+
+public interface IItemDeleter
+{
+    Task DeleteAsync(IContentProvider contentProvider, FullName fullName);
+}
+
+public interface IItemDeleter<in TContentProvider> : IItemDeleter where TContentProvider : IContentProvider
+{
+    Task DeleteAsync(TContentProvider contentProvider, FullName fullName);
+}

src/Core/FileTime.Core.Abstraction/Models/IItem.cs

@@ -1,7 +1,6 @@
 using System.Reactive.Linq;
 using FileTime.Core.ContentAccess;
 using FileTime.Core.Enums;
-using FileTime.Core.Services;
 using FileTime.Core.Timeline;
 
 namespace FileTime.Core.Models;
@@ -26,4 +25,4 @@ public interface IItem
     ReadOnlyExtensionCollection Extensions { get; }
 
     T? GetExtension<T>() => (T?)Extensions.FirstOrDefault(i => i is T);
-}
+}

src/Core/FileTime.Core.Command/Delete/DeleteCommand.cs

@@ -1,3 +1,5 @@
+using FileTime.Core.ContentAccess;
+using FileTime.Core.Extensions;
 using FileTime.Core.Models;
 using FileTime.Core.Timeline;
 
@@ -5,21 +7,76 @@ namespace FileTime.Core.Command.Delete;
 
 public class DeleteCommand : IExecutableCommand
 {
-    public bool HardDelete { get; init; }
-    public List<FullName> ItemsToDelete { get; } = new List<FullName>();
+    private readonly IContentAccessorFactory _contentAccessorFactory;
+    private readonly ITimelessContentProvider _timelessContentProvider;
+    public bool HardDelete { get; set; }
+    public List<FullName> ItemsToDelete { get; } = new();
+
+    public DeleteCommand(
+        IContentAccessorFactory contentAccessorFactory,
+        ITimelessContentProvider timelessContentProvider)
+    {
+        _contentAccessorFactory = contentAccessorFactory;
+        _timelessContentProvider = timelessContentProvider;
+    }
 
     public Task<CanCommandRun> CanRun(PointInTime currentTime)
     {
-        throw new NotImplementedException();
+        //TODO
+        return Task.FromResult(CanCommandRun.True);
     }
 
     public Task<PointInTime> SimulateCommand(PointInTime currentTime)
     {
-        throw new NotImplementedException();
+        //TODO
+        return Task.FromResult(currentTime);
     }
 
-    public Task Execute()
+    public async Task Execute()
     {
-        throw new NotImplementedException();
+        //Calculate
+
+        //Delete
+        await TraverseTree(
+            PointInTime.Present, 
+            ItemsToDelete, 
+            new Dictionary<string, IItemDeleter>(),
+            new DeleteStrategy()
+        );
+    }
+
+    private async Task TraverseTree(
+        PointInTime currentTime,
+        IEnumerable<FullName> itemsToDelete,
+        Dictionary<string, IItemDeleter> itemDeleters,
+        IDeleteStrategy deleteStrategy)
+    {
+        foreach (var itemToDeleteName in itemsToDelete)
+        {
+            var itemToDelete = await _timelessContentProvider.GetItemByFullNameAsync(itemToDeleteName, currentTime);
+            IItemDeleter itemDeleter;
+
+            if (itemDeleters.ContainsKey(itemToDelete.Provider.Name))
+            {
+                itemDeleter = itemDeleters[itemToDelete.Provider.Name];
+            }
+            else
+            {
+                itemDeleter = _contentAccessorFactory.GetItemDeleter(itemToDelete.Provider);
+                itemDeleters.Add(itemToDelete.Provider.Name, itemDeleter);
+            }
+
+            if (itemToDelete is IContainer container)
+            {
+                await TraverseTree(
+                    currentTime, 
+                    (await container.Items.GetItemsAsync())?.Select(i => i.Path) ?? Enumerable.Empty<FullName>(), 
+                    itemDeleters, 
+                    deleteStrategy
+                );
+            }
+
+            await itemDeleter.DeleteAsync(itemToDelete.Provider, itemToDelete.FullName!);
+        }
     }
 }

src/Core/FileTime.Core.Command/Delete/DeleteStrategy.cs

@@ -0,0 +1,12 @@
+using FileTime.Core.ContentAccess;
+using FileTime.Core.Models;
+
+namespace FileTime.Core.Command.Delete;
+
+public class DeleteStrategy : IDeleteStrategy
+{
+    public async Task DeleteItem(IItem item, IItemDeleter deleter)
+    {
+        await deleter.DeleteAsync(item.Provider, item.FullName!);
+    }
+}

src/Core/FileTime.Core.Command/Delete/IDeleteStrategy.cs

@@ -0,0 +1,9 @@
+using FileTime.Core.ContentAccess;
+using FileTime.Core.Models;
+
+namespace FileTime.Core.Command.Delete;
+
+public interface IDeleteStrategy
+{
+    Task DeleteItem(IItem item, IItemDeleter deleter);
+}

src/Core/FileTime.Core.ContentAccess/ContentAccessorFactory.cs

@@ -52,4 +52,18 @@ public class ContentAccessorFactory : IContentAccessorFactory
 
         return (IContentWriterFactory)_serviceProvider.GetRequiredService(genericType);
     }
+
+    public IItemDeleter<TContentProvider> GetItemDeleter<TContentProvider>() where TContentProvider : IContentProvider
+    {
+        var genericType = typeof(IItemDeleter<>).MakeGenericType(typeof(TContentProvider));
+
+        return (IItemDeleter<TContentProvider>)_serviceProvider.GetRequiredService(genericType);
+    }
+
+    public IItemDeleter GetItemDeleter(IContentProvider provider)
+    {
+        var genericType = typeof(IItemDeleter<>).MakeGenericType(provider.GetType());
+
+        return (IItemDeleter)_serviceProvider.GetRequiredService(genericType);
+    }
 }