Add download cleaner and dry run (#58)

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeClient.cs

@@ -62,6 +62,26 @@ public sealed class DelugeClient
             await ListTorrentsExtended(new Dictionary<string, string> { { "hash", hash } });
         return torrents.FirstOrDefault();
     }
+    
+    public async Task<TorrentStatus?> GetTorrentStatus(string hash)
+    {
+        return await SendRequest<TorrentStatus?>(
+            "web.get_torrent_status",
+            hash,
+            new[] { "hash", "state", "name", "eta", "private", "total_done", "label", "seeding_time", "ratio" }
+        );
+    }
+    
+    public async Task<List<TorrentStatus>?> GetStatusForAllTorrents()
+    {
+        Dictionary<string, TorrentStatus>? downloads = await SendRequest<Dictionary<string, TorrentStatus>?>(
+            "core.get_torrents_status",
+            "",
+            new[] { "hash", "state", "name", "eta", "private", "total_done", "label", "seeding_time", "ratio" }
+        );
+        
+        return downloads?.Values.ToList();
+    }
 
     public async Task<DelugeContents?> GetTorrentFiles(string hash)
     {
@@ -78,9 +98,9 @@ public sealed class DelugeClient
         await SendRequest<DelugeResponse<object>>("core.set_torrent_options", hash, filePriorities);
     }
 
-    public async Task<DelugeResponse<object>> DeleteTorrent(string hash)
+    public async Task DeleteTorrents(List<string> hashes)
     {
-        return await SendRequest<DelugeResponse<object>>("core.remove_torrents", new List<string> { hash }, true);
+        await SendRequest<DelugeResponse<object>>("core.remove_torrents", hashes, true);
     }
 
     private async Task<String> PostJson(String json)

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeService.cs

@@ -1,21 +1,31 @@
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
+using Common.Attributes;
 using Common.Configuration.ContentBlocker;
+using Common.Configuration.DownloadCleaner;
 using Common.Configuration.DownloadClient;
 using Common.Configuration.QueueCleaner;
 using Domain.Enums;
 using Domain.Models.Deluge.Response;
 using Infrastructure.Verticals.ContentBlocker;
+using Infrastructure.Verticals.Context;
 using Infrastructure.Verticals.ItemStriker;
+using Infrastructure.Verticals.Notifications;
+using MassTransit.Configuration;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
 namespace Infrastructure.Verticals.DownloadClient.Deluge;
 
-public sealed class DelugeService : DownloadServiceBase
+public class DelugeService : DownloadService, IDelugeService
 {
     private readonly DelugeClient _client;
+
+    /// <inheritdoc/>
+    public DelugeService()
+    {
+    }
     
     public DelugeService(
         ILogger<DelugeService> logger,
@@ -23,10 +33,12 @@ public sealed class DelugeService : DownloadServiceBase
         IHttpClientFactory httpClientFactory,
         IOptions<QueueCleanerConfig> queueCleanerConfig,
         IOptions<ContentBlockerConfig> contentBlockerConfig,
+        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
         IMemoryCache cache,
-        FilenameEvaluator filenameEvaluator,
-        Striker striker
-    ) : base(logger, queueCleanerConfig, contentBlockerConfig, cache, filenameEvaluator, striker)
+        IFilenameEvaluator filenameEvaluator,
+        IStriker striker,
+        NotificationPublisher notifier
+    ) : base(logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache, filenameEvaluator, striker, notifier)
     {
         config.Value.Validate();
         _client = new (config, httpClientFactory);
@@ -45,7 +57,7 @@ public sealed class DelugeService : DownloadServiceBase
         DelugeContents? contents = null;
         StalledResult result = new();
 
-        TorrentStatus? status = await GetTorrentStatus(hash);
+        TorrentStatus? status = await _client.GetTorrentStatus(hash);
         
         if (status?.Hash is null)
         {
@@ -98,7 +110,7 @@ public sealed class DelugeService : DownloadServiceBase
     {
         hash = hash.ToLowerInvariant();
 
-        TorrentStatus? status = await GetTorrentStatus(hash);
+        TorrentStatus? status = await _client.GetTorrentStatus(hash);
         BlockFilesResult result = new();
         
         if (status?.Hash is null)
@@ -178,17 +190,89 @@ public sealed class DelugeService : DownloadServiceBase
             return result;
         }
 
-        await _client.ChangeFilesPriority(hash, sortedPriorities);
+        await ((DelugeService)Proxy).ChangeFilesPriority(hash, sortedPriorities);
 
         return result;
     }
+
+    public override async Task<List<object>?> GetAllDownloadsToBeCleaned(List<Category> categories)
+    {
+        return (await _client.GetStatusForAllTorrents())
+            ?.Where(x => !string.IsNullOrEmpty(x.Hash))
+            .Where(x => x.State?.Equals("seeding", StringComparison.InvariantCultureIgnoreCase) is true)
+            .Where(x => categories.Any(cat => cat.Name.Equals(x.Label, StringComparison.InvariantCultureIgnoreCase)))
+            .Cast<object>()
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public override async Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes)
+    {
+        foreach (TorrentStatus download in downloads)
+        {
+            if (string.IsNullOrEmpty(download.Hash))
+            {
+                continue;
+            }
+            
+            Category? category = categoriesToClean
+                .FirstOrDefault(x => x.Name.Equals(download.Label, StringComparison.InvariantCultureIgnoreCase));
+
+            if (category is null)
+            {
+                continue;
+            }
+            
+            if (excludedHashes.Any(x => x.Equals(download.Hash, StringComparison.InvariantCultureIgnoreCase)))
+            {
+                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
+                continue;
+            }
+
+            if (!_downloadCleanerConfig.DeletePrivate && download.Private)
+            {
+                _logger.LogDebug("skip | download is private | {name}", download.Name);
+                continue;
+            }
+            
+            ContextProvider.Set("downloadName", download.Name);
+            ContextProvider.Set("hash", download.Hash);
+            
+            TimeSpan seedingTime = TimeSpan.FromSeconds(download.SeedingTime);
+            SeedingCheckResult result = ShouldCleanDownload(download.Ratio, seedingTime, category);
+
+            if (!result.ShouldClean)
+            {
+                continue;
+            }
+            
+            await ((DelugeService)Proxy).DeleteDownload(download.Hash);
+
+            _logger.LogInformation(
+                "download cleaned | {reason} reached | {name}",
+                result.Reason is CleanReason.MaxRatioReached
+                    ? "MAX_RATIO & MIN_SEED_TIME"
+                    : "MAX_SEED_TIME",
+                download.Name
+            );
+            
+            await _notifier.NotifyDownloadCleaned(download.Ratio, seedingTime, category.Name, result.Reason);
+        }
+    }
     
     /// <inheritdoc/>
-    public override async Task Delete(string hash)
+    [DryRunSafeguard]
+    public override async Task DeleteDownload(string hash)
     {
         hash = hash.ToLowerInvariant();
         
-        await _client.DeleteTorrent(hash);
+        await _client.DeleteTorrents([hash]);
+    }
+    
+    [DryRunSafeguard]
+    protected virtual async Task ChangeFilesPriority(string hash, List<int> sortedPriorities)
+    {
+        await _client.ChangeFilesPriority(hash, sortedPriorities);
     }
     
     private async Task<bool> IsItemStuckAndShouldRemove(TorrentStatus status)
@@ -219,15 +303,6 @@ public sealed class DelugeService : DownloadServiceBase
 
         return await StrikeAndCheckLimit(status.Hash!, status.Name!);
     }
-
-    private async Task<TorrentStatus?> GetTorrentStatus(string hash)
-    {
-        return await _client.SendRequest<TorrentStatus?>(
-            "web.get_torrent_status",
-            hash,
-            new[] { "hash", "state", "name", "eta", "private", "total_done" }
-        );
-    }
     
     private static void ProcessFiles(Dictionary<string, DelugeFileOrDirectory>? contents, Action<string, DelugeFileOrDirectory> processFile)
     {

code/Infrastructure/Verticals/DownloadClient/Deluge/IDelugeService.cs

@@ -0,0 +1,5 @@
+namespace Infrastructure.Verticals.DownloadClient.Deluge;
+
+public interface IDelugeService : IDownloadService
+{
+}

code/Infrastructure/Verticals/DownloadClient/DownloadService.cs

@@ -0,0 +1,183 @@
+using System.Collections.Concurrent;
+using System.Text.RegularExpressions;
+using Common.Configuration.ContentBlocker;
+using Common.Configuration.DownloadCleaner;
+using Common.Configuration.QueueCleaner;
+using Common.Helpers;
+using Domain.Enums;
+using Domain.Models.Cache;
+using Infrastructure.Helpers;
+using Infrastructure.Interceptors;
+using Infrastructure.Verticals.ContentBlocker;
+using Infrastructure.Verticals.Context;
+using Infrastructure.Verticals.ItemStriker;
+using Infrastructure.Verticals.Notifications;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Infrastructure.Verticals.DownloadClient;
+
+public abstract class DownloadService : InterceptedService, IDownloadService
+{
+    protected readonly ILogger<DownloadService> _logger;
+    protected readonly QueueCleanerConfig _queueCleanerConfig;
+    protected readonly ContentBlockerConfig _contentBlockerConfig;
+    protected readonly DownloadCleanerConfig _downloadCleanerConfig;
+    protected readonly IMemoryCache _cache;
+    protected readonly IFilenameEvaluator _filenameEvaluator;
+    protected readonly IStriker _striker;
+    protected readonly MemoryCacheEntryOptions _cacheOptions;
+    protected readonly NotificationPublisher _notifier;
+
+    /// <summary>
+    /// Constructor to be used by interceptors.
+    /// </summary>
+    protected DownloadService()
+    {
+    }
+    
+    protected DownloadService(
+        ILogger<DownloadService> logger,
+        IOptions<QueueCleanerConfig> queueCleanerConfig,
+        IOptions<ContentBlockerConfig> contentBlockerConfig,
+        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
+        IMemoryCache cache,
+        IFilenameEvaluator filenameEvaluator,
+        IStriker striker,
+        NotificationPublisher notifier)
+    {
+        _logger = logger;
+        _queueCleanerConfig = queueCleanerConfig.Value;
+        _contentBlockerConfig = contentBlockerConfig.Value;
+        _downloadCleanerConfig = downloadCleanerConfig.Value;
+        _cache = cache;
+        _filenameEvaluator = filenameEvaluator;
+        _striker = striker;
+        _notifier = notifier;
+        _cacheOptions = new MemoryCacheEntryOptions()
+            .SetSlidingExpiration(StaticConfiguration.TriggerValue + Constants.CacheLimitBuffer);
+    }
+
+    public abstract void Dispose();
+
+    public abstract Task LoginAsync();
+
+    public abstract Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash);
+
+    /// <inheritdoc/>
+    public abstract Task<BlockFilesResult> BlockUnwantedFilesAsync(
+        string hash,
+        BlocklistType blocklistType,
+        ConcurrentBag<string> patterns,
+        ConcurrentBag<Regex> regexes
+    );
+
+    /// <inheritdoc/>
+    public abstract Task DeleteDownload(string hash);
+
+    /// <inheritdoc/>
+    public abstract Task<List<object>?> GetAllDownloadsToBeCleaned(List<Category> categories);
+
+    /// <inheritdoc/>
+    public abstract Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes);
+
+    protected void ResetStrikesOnProgress(string hash, long downloaded)
+    {
+        if (!_queueCleanerConfig.StalledResetStrikesOnProgress)
+        {
+            return;
+        }
+        
+        if (_cache.TryGetValue(CacheKeys.Item(hash), out CacheItem? cachedItem) && cachedItem is not null && downloaded > cachedItem.Downloaded)
+        {
+            // cache item found
+            _cache.Remove(CacheKeys.Strike(StrikeType.Stalled, hash));
+            _logger.LogDebug("resetting strikes for {hash} due to progress", hash);
+        }
+        
+        _cache.Set(CacheKeys.Item(hash), new CacheItem { Downloaded = downloaded }, _cacheOptions);
+    }
+
+    /// <summary>
+    /// Strikes an item and checks if the limit has been reached.
+    /// </summary>
+    /// <param name="hash">The torrent hash.</param>
+    /// <param name="itemName">The name or title of the item.</param>
+    /// <returns>True if the limit has been reached; otherwise, false.</returns>
+    protected async Task<bool> StrikeAndCheckLimit(string hash, string itemName)
+    {
+        return await _striker.StrikeAndCheckLimit(hash, itemName, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled);
+    }
+    
+    protected SeedingCheckResult ShouldCleanDownload(double ratio, TimeSpan seedingTime, Category category)
+    {
+        // check ratio
+        if (DownloadReachedRatio(ratio, seedingTime, category))
+        {
+            return new()
+            {
+                ShouldClean = true,
+                Reason = CleanReason.MaxRatioReached
+            };
+        }
+            
+        // check max seed time
+        if (DownloadReachedMaxSeedTime(seedingTime, category))
+        {
+            return new()
+            {
+                ShouldClean = true,
+                Reason = CleanReason.MaxSeedTimeReached
+            };
+        }
+
+        return new();
+    }
+    
+    private bool DownloadReachedRatio(double ratio, TimeSpan seedingTime, Category category)
+    {
+        if (category.MaxRatio < 0)
+        {
+            return false;
+        }
+        
+        string downloadName = ContextProvider.Get<string>("downloadName");
+        TimeSpan minSeedingTime = TimeSpan.FromHours(category.MinSeedTime);
+        
+        if (category.MinSeedTime > 0 && seedingTime < minSeedingTime)
+        {
+            _logger.LogDebug("skip | download has not reached MIN_SEED_TIME | {name}", downloadName);
+            return false;
+        }
+
+        if (ratio < category.MaxRatio)
+        {
+            _logger.LogDebug("skip | download has not reached MAX_RATIO | {name}", downloadName);
+            return false;
+        }
+        
+        // max ration is 0 or reached
+        return true;
+    }
+    
+    private bool DownloadReachedMaxSeedTime(TimeSpan seedingTime, Category category)
+    {
+        if (category.MaxSeedTime < 0)
+        {
+            return false;
+        }
+        
+        string downloadName = ContextProvider.Get<string>("downloadName");
+        TimeSpan maxSeedingTime = TimeSpan.FromHours(category.MaxSeedTime);
+        
+        if (category.MaxSeedTime > 0 && seedingTime < maxSeedingTime)
+        {
+            _logger.LogDebug("skip | download has not reached MAX_SEED_TIME | {name}", downloadName);
+            return false;
+        }
+
+        // max seed time is 0 or reached
+        return true;
+    }
+}

code/Infrastructure/Verticals/DownloadClient/DownloadServiceBase.cs

@@ -1,90 +0,0 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.QueueCleaner;
-using Common.Helpers;
-using Domain.Enums;
-using Domain.Models.Cache;
-using Infrastructure.Helpers;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.ItemStriker;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Verticals.DownloadClient;
-
-public abstract class DownloadServiceBase : IDownloadService
-{
-    protected readonly ILogger<DownloadServiceBase> _logger;
-    protected readonly QueueCleanerConfig _queueCleanerConfig;
-    protected readonly ContentBlockerConfig _contentBlockerConfig;
-    protected readonly IMemoryCache _cache;
-    protected readonly FilenameEvaluator _filenameEvaluator;
-    protected readonly Striker _striker;
-    protected readonly MemoryCacheEntryOptions _cacheOptions;
-    
-    protected DownloadServiceBase(
-        ILogger<DownloadServiceBase> logger,
-        IOptions<QueueCleanerConfig> queueCleanerConfig,
-        IOptions<ContentBlockerConfig> contentBlockerConfig,
-        IMemoryCache cache,
-        FilenameEvaluator filenameEvaluator,
-        Striker striker
-    )
-    {
-        _logger = logger;
-        _queueCleanerConfig = queueCleanerConfig.Value;
-        _contentBlockerConfig = contentBlockerConfig.Value;
-        _cache = cache;
-        _filenameEvaluator = filenameEvaluator;
-        _striker = striker;
-        _cacheOptions = new MemoryCacheEntryOptions()
-            .SetSlidingExpiration(StaticConfiguration.TriggerValue + Constants.CacheLimitBuffer);
-    }
-
-    public abstract void Dispose();
-
-    public abstract Task LoginAsync();
-
-    public abstract Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash);
-
-    /// <inheritdoc/>
-    public abstract Task<BlockFilesResult> BlockUnwantedFilesAsync(
-        string hash,
-        BlocklistType blocklistType,
-        ConcurrentBag<string> patterns,
-        ConcurrentBag<Regex> regexes
-    );
-
-    /// <inheritdoc/>
-    public abstract Task Delete(string hash);
-
-    protected void ResetStrikesOnProgress(string hash, long downloaded)
-    {
-        if (!_queueCleanerConfig.StalledResetStrikesOnProgress)
-        {
-            return;
-        }
-        
-        if (_cache.TryGetValue(CacheKeys.Item(hash), out CacheItem? cachedItem) && cachedItem is not null && downloaded > cachedItem.Downloaded)
-        {
-            // cache item found
-            _cache.Remove(CacheKeys.Strike(StrikeType.Stalled, hash));
-            _logger.LogDebug("resetting strikes for {hash} due to progress", hash);
-        }
-        
-        _cache.Set(CacheKeys.Item(hash), new CacheItem { Downloaded = downloaded }, _cacheOptions);
-    }
-
-    /// <summary>
-    /// Strikes an item and checks if the limit has been reached.
-    /// </summary>
-    /// <param name="hash">The torrent hash.</param>
-    /// <param name="itemName">The name or title of the item.</param>
-    /// <returns>True if the limit has been reached; otherwise, false.</returns>
-    protected async Task<bool> StrikeAndCheckLimit(string hash, string itemName)
-    {
-        return await _striker.StrikeAndCheckLimit(hash, itemName, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled);
-    }
-}

code/Infrastructure/Verticals/DownloadClient/DummyDownloadService.cs

@@ -1,18 +1,20 @@
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
 using Common.Configuration.ContentBlocker;
+using Common.Configuration.DownloadCleaner;
 using Common.Configuration.QueueCleaner;
 using Infrastructure.Verticals.ContentBlocker;
 using Infrastructure.Verticals.ItemStriker;
+using Infrastructure.Verticals.Notifications;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
 namespace Infrastructure.Verticals.DownloadClient;
 
-public sealed class DummyDownloadService : DownloadServiceBase
+public sealed class DummyDownloadService : DownloadService
 {
-    public DummyDownloadService(ILogger<DownloadServiceBase> logger, IOptions<QueueCleanerConfig> queueCleanerConfig, IOptions<ContentBlockerConfig> contentBlockerConfig, IMemoryCache cache, FilenameEvaluator filenameEvaluator, Striker striker) : base(logger, queueCleanerConfig, contentBlockerConfig, cache, filenameEvaluator, striker)
+    public DummyDownloadService(ILogger<DownloadService> logger, IOptions<QueueCleanerConfig> queueCleanerConfig, IOptions<ContentBlockerConfig> contentBlockerConfig, IOptions<DownloadCleanerConfig> downloadCleanerConfig, IMemoryCache cache, IFilenameEvaluator filenameEvaluator, IStriker striker, NotificationPublisher notifier) : base(logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache, filenameEvaluator, striker, notifier)
     {
     }
 
@@ -35,7 +37,17 @@ public sealed class DummyDownloadService : DownloadServiceBase
         throw new NotImplementedException();
     }
 
-    public override Task Delete(string hash)
+    public override Task<List<object>?> GetAllDownloadsToBeCleaned(List<Category> categories)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override Task DeleteDownload(string hash)
     {
         throw new NotImplementedException();
     }

code/Infrastructure/Verticals/DownloadClient/IDownloadService.cs

@@ -1,10 +1,12 @@
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
 using Common.Configuration.ContentBlocker;
+using Common.Configuration.DownloadCleaner;
+using Infrastructure.Interceptors;
 
 namespace Infrastructure.Verticals.DownloadClient;
 
-public interface IDownloadService : IDisposable
+public interface IDownloadService : IDisposable, IDryRunService
 {
     public Task LoginAsync();
 
@@ -29,8 +31,23 @@ public interface IDownloadService : IDisposable
         ConcurrentBag<Regex> regexes
     );
 
+    /// <summary>
+    /// Fetches all downloads.
+    /// </summary>
+    /// <param name="categories">The categories by which to filter the downloads.</param>
+    /// <returns>A list of downloads for the provided categories.</returns>
+    Task<List<object>?> GetAllDownloadsToBeCleaned(List<Category> categories);
+    
+    /// <summary>
+    /// Cleans the downloads.
+    /// </summary>
+    /// <param name="downloads"></param>
+    /// <param name="categoriesToClean">The categories that should be cleaned.</param>
+    /// <param name="excludedHashes">The hashes that should not be cleaned.</param>
+    public abstract Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes);
+
     /// <summary>
     /// Deletes a download item.
     /// </summary>
-    public Task Delete(string hash);
+    public Task DeleteDownload(string hash);
 }

code/Infrastructure/Verticals/DownloadClient/QBittorrent/IQBitService.cs

@@ -0,0 +1,5 @@
+namespace Infrastructure.Verticals.DownloadClient.QBittorrent;
+
+public interface IQBitService : IDownloadService
+{
+}

code/Infrastructure/Verticals/DownloadClient/QBittorrent/QBitService.cs

@@ -1,34 +1,46 @@
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
+using Common.Attributes;
 using Common.Configuration.ContentBlocker;
+using Common.Configuration.DownloadCleaner;
 using Common.Configuration.DownloadClient;
 using Common.Configuration.QueueCleaner;
 using Common.Helpers;
 using Domain.Enums;
 using Infrastructure.Verticals.ContentBlocker;
+using Infrastructure.Verticals.Context;
 using Infrastructure.Verticals.ItemStriker;
+using Infrastructure.Verticals.Notifications;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using QBittorrent.Client;
+using Category = Common.Configuration.DownloadCleaner.Category;
 
 namespace Infrastructure.Verticals.DownloadClient.QBittorrent;
 
-public sealed class QBitService : DownloadServiceBase
+public class QBitService : DownloadService, IQBitService
 {
     private readonly QBitConfig _config;
     private readonly QBittorrentClient _client;
 
+    /// <inheritdoc/>
+    public QBitService()
+    {
+    }
+    
     public QBitService(
         ILogger<QBitService> logger,
         IHttpClientFactory httpClientFactory,
         IOptions<QBitConfig> config,
         IOptions<QueueCleanerConfig> queueCleanerConfig,
         IOptions<ContentBlockerConfig> contentBlockerConfig,
+        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
         IMemoryCache cache,
-        FilenameEvaluator filenameEvaluator,
-        Striker striker
-    ) : base(logger, queueCleanerConfig, contentBlockerConfig, cache, filenameEvaluator, striker)
+        IFilenameEvaluator filenameEvaluator,
+        IStriker striker,
+        NotificationPublisher notifier
+    ) : base(logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache, filenameEvaluator, striker, notifier)
     {
         _config = config.Value;
         _config.Validate();
@@ -188,17 +200,98 @@ public sealed class QBitService : DownloadServiceBase
 
         foreach (int fileIndex in unwantedFiles)
         {
-            await _client.SetFilePriorityAsync(hash, fileIndex, TorrentContentPriority.Skip);
+            await ((QBitService)Proxy).SkipFile(hash, fileIndex);
         }
         
         return result;
     }
+    
+    /// <inheritdoc/>
+    public override async Task<List<object>?> GetAllDownloadsToBeCleaned(List<Category> categories) =>
+        (await _client.GetTorrentListAsync(new()
+        {
+            Filter = TorrentListFilter.Seeding
+        }))
+        ?.Where(x => !string.IsNullOrEmpty(x.Hash))
+        .Where(x => categories.Any(cat => cat.Name.Equals(x.Category, StringComparison.InvariantCultureIgnoreCase)))
+        .Cast<object>()
+        .ToList();
 
     /// <inheritdoc/>
-    public override async Task Delete(string hash)
+    public override async Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes)
+    {
+        foreach (TorrentInfo download in downloads)
+        {
+            if (string.IsNullOrEmpty(download.Hash))
+            {
+                continue;
+            }
+            
+            Category? category = categoriesToClean
+                .FirstOrDefault(x => download.Category.Equals(x.Name, StringComparison.InvariantCultureIgnoreCase));
+            
+            if (category is null)
+            {
+                continue;
+            }
+            
+            if (excludedHashes.Any(x => x.Equals(download.Hash, StringComparison.InvariantCultureIgnoreCase)))
+            {
+                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
+                continue;
+            }
+            
+            if (!_downloadCleanerConfig.DeletePrivate)
+            {
+                TorrentProperties? torrentProperties = await _client.GetTorrentPropertiesAsync(download.Hash);
+
+                bool isPrivate = torrentProperties.AdditionalData.TryGetValue("is_private", out var dictValue) &&
+                                 bool.TryParse(dictValue?.ToString(), out bool boolValue)
+                                 && boolValue;
+
+                if (isPrivate)
+                {
+                    _logger.LogDebug("skip | download is private | {name}", download.Name);
+                    continue;
+                }
+            }
+            
+            ContextProvider.Set("downloadName", download.Name);
+            ContextProvider.Set("hash", download.Hash);
+
+            SeedingCheckResult result = ShouldCleanDownload(download.Ratio, download.SeedingTime ?? TimeSpan.Zero, category);
+
+            if (!result.ShouldClean)
+            {
+                continue;
+            }
+
+            await ((QBitService)Proxy).DeleteDownload(download.Hash);
+
+            _logger.LogInformation(
+                "download cleaned | {reason} reached | {name}",
+                result.Reason is CleanReason.MaxRatioReached
+                    ? "MAX_RATIO & MIN_SEED_TIME"
+                    : "MAX_SEED_TIME",
+                download.Name
+            );
+            
+            await _notifier.NotifyDownloadCleaned(download.Ratio, download.SeedingTime ?? TimeSpan.Zero, category.Name, result.Reason);
+        }
+    }
+
+    /// <inheritdoc/>
+    [DryRunSafeguard]
+    public override async Task DeleteDownload(string hash)
     {
         await _client.DeleteAsync(hash, deleteDownloadedData: true);
     }
+    
+    [DryRunSafeguard]
+    protected virtual async Task SkipFile(string hash, int fileIndex)
+    {
+        await _client.SetFilePriorityAsync(hash, fileIndex, TorrentContentPriority.Skip);
+    }
 
     public override void Dispose()
     {

code/Infrastructure/Verticals/DownloadClient/SeedingCheckResult.cs

@@ -0,0 +1,9 @@
+using Domain.Enums;
+
+namespace Infrastructure.Verticals.DownloadClient;
+
+public sealed record SeedingCheckResult
+{
+    public bool ShouldClean { get; set; }
+    public CleanReason Reason { get; set; }    
+}

code/Infrastructure/Verticals/DownloadClient/Transmission/ITransmissionService.cs

@@ -0,0 +1,5 @@
+namespace Infrastructure.Verticals.DownloadClient.Transmission;
+
+public interface ITransmissionService : IDownloadService
+{
+}

code/Infrastructure/Verticals/DownloadClient/Transmission/TransmissionService.cs

@@ -1,12 +1,16 @@
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
+using Common.Attributes;
 using Common.Configuration.ContentBlocker;
+using Common.Configuration.DownloadCleaner;
 using Common.Configuration.DownloadClient;
 using Common.Configuration.QueueCleaner;
 using Common.Helpers;
 using Domain.Enums;
 using Infrastructure.Verticals.ContentBlocker;
+using Infrastructure.Verticals.Context;
 using Infrastructure.Verticals.ItemStriker;
+using Infrastructure.Verticals.Notifications;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -16,22 +20,29 @@ using Transmission.API.RPC.Entity;
 
 namespace Infrastructure.Verticals.DownloadClient.Transmission;
 
-public sealed class TransmissionService : DownloadServiceBase
+public class TransmissionService : DownloadService, ITransmissionService
 {
     private readonly TransmissionConfig _config;
     private readonly Client _client;
     private TorrentInfo[]? _torrentsCache;
 
+    /// <inheritdoc/>
+    public TransmissionService()
+    {
+    }
+    
     public TransmissionService(
         IHttpClientFactory httpClientFactory,
         ILogger<TransmissionService> logger,
         IOptions<TransmissionConfig> config,
         IOptions<QueueCleanerConfig> queueCleanerConfig,
         IOptions<ContentBlockerConfig> contentBlockerConfig,
+        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
         IMemoryCache cache,
-        FilenameEvaluator filenameEvaluator,
-        Striker striker
-    ) : base(logger, queueCleanerConfig, contentBlockerConfig, cache, filenameEvaluator, striker)
+        IFilenameEvaluator filenameEvaluator,
+        IStriker striker,
+        NotificationPublisher notifier
+    ) : base(logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache, filenameEvaluator, striker, notifier)
     {
         _config = config.Value;
         _config.Validate();
@@ -164,16 +175,96 @@ public sealed class TransmissionService : DownloadServiceBase
         
         _logger.LogDebug("changing priorities | torrent {hash}", hash);
         
-        await _client.TorrentSetAsync(new TorrentSettings
-        {
-            Ids = [ torrent.Id ],
-            FilesUnwanted = unwantedFiles.ToArray(),
-        });
+        await ((TransmissionService)Proxy).SetUnwantedFiles(torrent.Id, unwantedFiles.ToArray());
 
         return result;
     }
 
-    public override async Task Delete(string hash)
+    /// <inheritdoc/>
+    public override async Task<List<object>?> GetAllDownloadsToBeCleaned(List<Category> categories)
+    {
+        string[] fields = [
+            TorrentFields.FILES,
+            TorrentFields.FILE_STATS,
+            TorrentFields.HASH_STRING,
+            TorrentFields.ID,
+            TorrentFields.ETA,
+            TorrentFields.NAME,
+            TorrentFields.STATUS,
+            TorrentFields.IS_PRIVATE,
+            TorrentFields.DOWNLOADED_EVER,
+            TorrentFields.DOWNLOAD_DIR,
+            TorrentFields.SECONDS_SEEDING,
+            TorrentFields.UPLOAD_RATIO
+        ];
+            
+        return (await _client.TorrentGetAsync(fields))
+            ?.Torrents
+            ?.Where(x => !string.IsNullOrEmpty(x.HashString))
+            .Where(x => x.Status is 5 or 6)
+            .Where(x => categories
+                .Any(cat => x.DownloadDir?.EndsWith(cat.Name, StringComparison.InvariantCultureIgnoreCase) is true)
+            )
+            .Cast<object>()
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public override async Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes)
+    {
+        foreach (TorrentInfo download in downloads)
+        {
+            if (string.IsNullOrEmpty(download.HashString))
+            {
+                continue;
+            }
+            
+            Category? category = categoriesToClean
+                .FirstOrDefault(x => download.DownloadDir?.EndsWith(x.Name, StringComparison.InvariantCultureIgnoreCase) is true);
+
+            if (category is null)
+            {
+                continue;
+            }
+
+            if (excludedHashes.Any(x => x.Equals(download.HashString, StringComparison.InvariantCultureIgnoreCase)))
+            {
+                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
+                continue;
+            }
+
+            if (!_downloadCleanerConfig.DeletePrivate && download.IsPrivate is true)
+            {
+                _logger.LogDebug("skip | download is private | {name}", download.Name);
+                continue;
+            }
+            
+            ContextProvider.Set("downloadName", download.Name);
+            ContextProvider.Set("hash", download.HashString);
+
+            TimeSpan seedingTime = TimeSpan.FromSeconds(download.SecondsSeeding ?? 0);
+            SeedingCheckResult result = ShouldCleanDownload(download.uploadRatio ?? 0, seedingTime, category);
+            
+            if (!result.ShouldClean)
+            {
+                continue;
+            }
+
+            await ((TransmissionService)Proxy).RemoveDownloadAsync(download.Id);
+
+            _logger.LogInformation(
+                "download cleaned | {reason} reached | {name}",
+                result.Reason is CleanReason.MaxRatioReached
+                    ? "MAX_RATIO & MIN_SEED_TIME"
+                    : "MAX_SEED_TIME",
+                download.Name
+            );
+
+            await _notifier.NotifyDownloadCleaned(download.uploadRatio ?? 0, seedingTime, category.Name, result.Reason);
+        }
+    }
+    
+    public override async Task DeleteDownload(string hash)
     {
         TorrentInfo? torrent = await GetTorrentAsync(hash);
 
@@ -189,6 +280,22 @@ public sealed class TransmissionService : DownloadServiceBase
     {
     }
     
+    [DryRunSafeguard]
+    protected virtual async Task RemoveDownloadAsync(long downloadId)
+    {
+        await _client.TorrentRemoveAsync([downloadId], true);
+    }
+    
+    [DryRunSafeguard]
+    protected virtual async Task SetUnwantedFiles(long downloadId, long[] unwantedFiles)
+    {
+        await _client.TorrentSetAsync(new TorrentSettings
+        {
+            Ids = [downloadId],
+            FilesUnwanted = unwantedFiles,
+        });
+    }
+    
     private async Task<bool> IsItemStuckAndShouldRemove(TorrentInfo torrent)
     {
         if (_queueCleanerConfig.StalledMaxStrikes is 0)