fix: Correção na feature de deletar imagens na Bucket

Bom foi adaptado para remover mais de uuma imagem de uma vez, além de salvar como deletada no banco que ficou faltando na primeira versão do CleanupImageBucketJob.

Também foi feita a correção nos testes para ficar de acordo com a nova versão do método de deletar imagem.

Author: samuelzedec

src/Riber.Application/Abstractions/Services/IImageStorageService.cs

@@ -23,9 +23,9 @@ public interface IImageStorageService
     Task<Stream> GetImageStreamAsync(string fileName);
 
     /// <summary>
-    /// Remove uma imagem do serviço de armazenamento.
+    /// Remove uma ou mais imagens do serviço de armazenamento.
     /// </summary>
-    /// <param name="fileName">O nome do arquivo da imagem a ser removida.</param>
-    /// <returns>Uma task representando a operação assíncrona.</returns>
-    Task DeleteAsync(string fileName);
+    /// <param name="fileKeys">As chaves dos arquivos das imagens que devem ser removidas.</param>
+    /// <returns>Um IEnumerable contendo as chaves dos arquivos que foram excluídos.</returns>
+    Task<IEnumerable<string>> DeleteAllAsync(List<string> fileKeys);
 }

src/Riber.Domain/Repositories/IProductRepository.cs

@@ -80,4 +80,10 @@ Task<IEnumerable<ProductCategory>> GetCategoriesAsync(
     /// <param name="cancellationToken">Token para cancelamento da operação assíncrona.</param>
     /// <returns>Uma coleção de imagens não utilizadas.</returns>
     Task<IReadOnlyList<Image>> GetUnusedImagesAsync(CancellationToken cancellationToken = default);
+    
+    /// <summary>
+    /// Remove uma imagem específica do serviço de armazenamento.
+    /// </summary>
+    /// <param name="image">A imagem que deve ser removida.</param>
+    void DeleteImage(Image image);
 }

src/Riber.Infrastructure/BackgroundJobs/CleanupImageBucketJob.cs

@@ -8,46 +8,45 @@ namespace Riber.Infrastructure.BackgroundJobs;
 
 internal sealed class CleanupImageBucketJob(
     IImageStorageService imageStorageService,
-    IProductRepository productRepository,
+    IUnitOfWork unitOfWork,
     ILogger<CleanupImageBucketJob> logger)
     : IJob
 {
     public async Task Execute(IJobExecutionContext context)
     {
-        var unusedImages = await productRepository.GetUnusedImagesAsync(context.CancellationToken);
-        if (unusedImages.Count == 0)
+        try
         {
-            logger.LogInformation("No unused images found for cleanup.");
-            return;
-        }
+            var unusedImages = await unitOfWork.Products.GetUnusedImagesAsync(context.CancellationToken);
+            if (unusedImages.Count == 0)
+            {
+                logger.LogInformation("No unused images found for cleanup.");
+                return;
+            }
 
-        logger.LogInformation("Starting cleanup of {Count} unused images.", unusedImages.Count);
-        int deletedCount = 0;
-        int failedCount = 0;
+            logger.LogInformation("Starting cleanup of {Count} unused images.", unusedImages.Count);
+            var unusedImageKeys = unusedImages.Select(x => x.ToString()).ToList();
 
-        foreach (Image unusedImage in unusedImages)
+            var deletedKeys = (await imageStorageService.DeleteAllAsync(unusedImageKeys)).ToHashSet();
+            await MarkImageAsDeletedAsync(unusedImages, deletedKeys);
+        }
+        catch (Exception ex)
         {
-            try
-            {
-                await imageStorageService.DeleteAsync(unusedImage);
-                deletedCount++;
-                logger.LogDebug("Successfully deleted image {ImageId}.", unusedImage.Id);
-            }
-            catch (Exception ex)
-            {
-                failedCount++;
-                logger.LogError(ex,
-                    "Failed to delete image {ImageId} - {ImageName}.",
-                    unusedImage.Id,
-                    unusedImage.ToString()
-                );
-            }
+            logger.LogError(ex, "Failed to delete images from storage service.");
         }
+    }
+
+    private async Task MarkImageAsDeletedAsync(IReadOnlyList<Image> unusedImage, HashSet<string> deletedKeys)
+    {
+        var imagesForDeletion = unusedImage
+            .Where(image => deletedKeys.Contains(image.ToString()))
+            .ToList();
+
+        if (imagesForDeletion.Count == 0)
+            return;
+
+        foreach (var image in imagesForDeletion)
+            unitOfWork.Products.DeleteImage(image);
 
-        logger.LogInformation(
-            "Image cleanup completed. Successfully deleted: {Deleted}, Failed: {Failed}",
-            deletedCount,
-            failedCount
-        );
+        await unitOfWork.SaveChangesAsync();
     }
 }

src/Riber.Infrastructure/Persistence/Repositories/ProductRepository.cs

@@ -43,4 +43,7 @@ public async Task<IReadOnlyList<Image>> GetUnusedImagesAsync(CancellationToken c
             .AsNoTracking()
             .Where(new ImagesReadyForCleanupSpecification())
             .ToListAsync(cancellationToken);
+    
+    public void DeleteImage(Image image)
+        => _images.Remove(image);
 }

src/Riber.Infrastructure/Services/AWS/AmazonS3Service.cs

@@ -25,8 +25,7 @@ public AmazonS3Service(
                       ?? throw new ArgumentNullException(nameof(configuration), "Configuration cannot be null");
 
         if (string.IsNullOrWhiteSpace(_bucketName))
-            throw new InvalidOperationException(
-                "AWS S3 bucket name is not configured. Please set 'AWS:S3:BucketImagesName' in configuration.");
+            throw new InvalidOperationException("AWS S3 bucket name is not configured. Please set 'AWS:S3:BucketImagesName' in configuration.");
     }
 
     public async Task UploadAsync(Stream stream, string fileName, string contentType)
@@ -76,7 +75,7 @@ public async Task<Stream> GetImageStreamAsync(string fileName)
             var request = new GetObjectRequest { BucketName = _bucketName, Key = fileName };
             var response = await _amazonS3.GetObjectAsync(request);
 
-            _logger.LogDebug("Successfully retrieved image {FileName} from S3 bucket {BucketName}", 
+            _logger.LogDebug("Successfully retrieved image {FileName} from S3 bucket {BucketName}",
                 fileName, _bucketName);
 
             return response.ResponseStream;
@@ -103,15 +102,28 @@ public async Task<Stream> GetImageStreamAsync(string fileName)
         }
     }
 
-    public async Task DeleteAsync(string fileName)
+    public async Task<IEnumerable<string>> DeleteAllAsync(List<string> fileKeys)
     {
         try
         {
-            var request = new DeleteObjectRequest { BucketName = _bucketName, Key = fileName };
+            var request = new DeleteObjectsRequest
+            {
+                BucketName = _bucketName, 
+                Objects = [.. fileKeys.Select(x => new KeyVersion { Key = x })]
+            };
 
-            await _amazonS3.DeleteObjectAsync(request);
-            _logger.LogDebug("Successfully deleted image {FileName} from S3 bucket {BucketName}",
-                fileName, _bucketName);
+            var response = await _amazonS3.DeleteObjectsAsync(request);
+            List<string> deletedKeys = [.. response.DeletedObjects.Select(x => x.Key)];
+            var failedCount = response.DeleteErrors.Count;
+
+            _logger.LogInformation(
+                "Deleted {SuccessCount} image(s), failed to delete {FailedCount} image(s) from S3 bucket {BucketName}",
+                deletedKeys.Count,
+                failedCount,
+                _bucketName
+            );
+
+            return deletedKeys;
         }
         catch (Exception ex)
         {

src/Riber.Infrastructure/Services/Local/LocalImageStorageService.cs

@@ -53,13 +53,20 @@ public Task<Stream> GetImageStreamAsync(string fileName)
             );
     }
 
-    public Task DeleteAsync(string fileName)
+    public Task<IEnumerable<string>> DeleteAllAsync(List<string> fileKeys)
     {
-        var imagePath = Path.Combine(_storagePath, fileName);
-        if (!File.Exists(imagePath))
-            throw new NotFoundException(StorageErrors.ImageNotFound);
+        List<string> deletedKeys = [];
+        foreach (var fileKey in fileKeys)
+        {
+            var imagePath = Path.Combine(_storagePath, fileKey);
+            if (!File.Exists(imagePath))
+                continue;
 
-        File.Delete(imagePath);
-        return Task.CompletedTask;
+            File.Delete(imagePath);
+            deletedKeys.Add(fileKey);
+        }
+        
+        _logger.LogInformation("Deleted {Count} file(s)", deletedKeys.Count);
+        return Task.FromResult(deletedKeys.AsEnumerable());
     }
 }