[feature] Enable cleanup in CloudflareR2 post-process (#164)

Ghass-M · web-flow · commit 3c605619d5c2 · 2025-08-12T10:41:54.000+01:00
diff --git a/src/ByteSync.Client/Services/Communications/Transfers/FileDownloader.cs b/src/ByteSync.Client/Services/Communications/Transfers/FileDownloader.cs
@@ -107,26 +107,27 @@ private async Task DownloadFile()
                     break;
                 }
 
-                var response = await policy.ExecuteAsync(async () =>
+                var transferParameters = new TransferParameters
+                {
+                    SessionId = SharedFileDefinition.SessionId,
+                    SharedFileDefinition = SharedFileDefinition,
+                    PartNumber = partNumber
+                };
+                var downloadLocation = await _fileTransferApiClient.GetDownloadFileStorageLocation(transferParameters);
+                var storageProvider = downloadLocation.StorageProvider;
+                
+                var downloadResponse = await policy.ExecuteAsync(async () =>
                 {
-                    var transferParameters = new TransferParameters
-                    {
-                        SessionId = SharedFileDefinition.SessionId,
-                        SharedFileDefinition = SharedFileDefinition,
-                        PartNumber = partNumber
-                    };
-                    var downloadLocation = await _fileTransferApiClient.GetDownloadFileStorageLocation(transferParameters);
-                    
                     var memoryStream = new MemoryStream();
-                    var downloadStrategy = _strategies[downloadLocation.StorageProvider];
+                    var downloadStrategy = _strategies[storageProvider];
                     var response = await downloadStrategy.DownloadAsync(memoryStream, downloadLocation, CancellationTokenSource.Token);
                     
                     DownloadTarget.AddOrReplaceMemoryStream(partNumber, memoryStream);
                     return response;
                 });
-                if (response.IsSuccess)
+                if (downloadResponse.IsSuccess)
                 {
-                    await AssertFilePartIsDownloaded(partNumber);
+                    await AssertFilePartIsDownloaded(partNumber, storageProvider);
                     await _semaphoreSlim.WaitAsync();
                     try
                     {
@@ -166,14 +167,16 @@ private async Task DownloadFile()
         }
     }
 
-    private async Task AssertFilePartIsDownloaded(int partNumber)
+    private async Task AssertFilePartIsDownloaded(int partNumber, StorageProvider storageProvider)
     {
         var transferParameters = new TransferParameters
         {
             SessionId = SharedFileDefinition.SessionId,
             SharedFileDefinition = SharedFileDefinition,
-            PartNumber = partNumber
+            PartNumber = partNumber,
+            StorageProvider = storageProvider
         };
+        
         await _filePartDownloadAsserter.AssertAsync(transferParameters);
     }
     
diff --git a/src/ByteSync.Common/Business/SharedFiles/TransferParameters.cs b/src/ByteSync.Common/Business/SharedFiles/TransferParameters.cs
@@ -13,4 +13,6 @@ public class TransferParameters
     public int? TotalParts { get; set; }
     
     public List<string>? ActionsGroupIds { get; set; }
+    
+    public StorageProvider StorageProvider { get; set; }
 }
diff --git a/src/ByteSync.ServerCommon/Business/Sessions/SharedFileData.cs b/src/ByteSync.ServerCommon/Business/Sessions/SharedFileData.cs
@@ -9,8 +9,8 @@ public SharedFileData()
     {
         
     }
-    
-    public SharedFileData(SharedFileDefinition sharedFileDefinition, ICollection<string> recipients)
+
+    public SharedFileData(SharedFileDefinition sharedFileDefinition, ICollection<string> recipients, StorageProvider storageProvider)
     {
         SharedFileDefinition = sharedFileDefinition;
 
@@ -24,11 +24,13 @@ public SharedFileData(SharedFileDefinition sharedFileDefinition, ICollection<str
             {
                 cleanedData = recipient.Substring("CIID_".Length);
             }
-                
+
             Recipients.Add(cleanedData);
         }
-            
+
         DownloadedBy = new Dictionary<int, HashSet<string>>();
+
+        StorageProvider = storageProvider;
     }
 
     public SharedFileDefinition SharedFileDefinition { get; set; } = null!;
@@ -78,4 +80,6 @@ public bool IsPartFullyDownloaded(int partNumber)
 
         return false;
     }
+    
+    public StorageProvider StorageProvider { get; set; }
 }
diff --git a/src/ByteSync.ServerCommon/Commands/FileTransfers/AssertFilePartIsDownloadedCommandHandler.cs b/src/ByteSync.ServerCommon/Commands/FileTransfers/AssertFilePartIsDownloadedCommandHandler.cs
@@ -31,7 +31,7 @@ public async Task Handle(AssertFilePartIsDownloadedRequest request, Cancellation
 
         if (_transferLocationService.IsSharedFileDefinitionAllowed(sessionMemberData, sharedFileDefinition))
         {
-            await _sharedFilesService.AssertFilePartIsDownloaded(sharedFileDefinition, request.Client, partNumber);
+            await _sharedFilesService.AssertFilePartIsDownloaded(request.Client, request.TransferParameters);
         }
         
         _logger.LogDebug("File part download asserted for session {SessionId}, file {FileId}, part {PartNumber}", 
diff --git a/src/ByteSync.ServerCommon/Commands/FileTransfers/AssertFilePartIsUploadedCommandHandler.cs b/src/ByteSync.ServerCommon/Commands/FileTransfers/AssertFilePartIsUploadedCommandHandler.cs
@@ -51,7 +51,7 @@ public async Task Handle(AssertFilePartIsUploadedRequest request, CancellationTo
             {
                 var otherSessionMembers = GetOtherSessionMembers(session!, sessionMemberData);
                 
-                await _sharedFilesService.AssertFilePartIsUploaded(sharedFileDefinition, partNumber, 
+                await _sharedFilesService.AssertFilePartIsUploaded(request.TransferParameters, 
                     otherSessionMembers.Select(sm => sm.ClientInstanceId).ToList());
 
                 var transferPush = new FileTransferPush
diff --git a/src/ByteSync.ServerCommon/Commands/FileTransfers/AssertUploadIsFinishedCommandHandler.cs b/src/ByteSync.ServerCommon/Commands/FileTransfers/AssertUploadIsFinishedCommandHandler.cs
@@ -47,7 +47,7 @@ public async Task Handle(AssertUploadIsFinishedRequest request, CancellationToke
             {
                 var otherSessionMembers = GetOtherSessionMembers(session!, sessionMemberData);
                 
-                await _sharedFilesService.AssertUploadIsFinished(sharedFileDefinition, totalParts, 
+                await _sharedFilesService.AssertUploadIsFinished(request.TransferParameters, 
                     otherSessionMembers.Select(sm => sm.ClientInstanceId).ToList());
 
                 var transferPush = new FileTransferPush
diff --git a/src/ByteSync.ServerCommon/Interfaces/Services/ISharedFilesService.cs b/src/ByteSync.ServerCommon/Interfaces/Services/ISharedFilesService.cs
@@ -5,11 +5,11 @@ namespace ByteSync.ServerCommon.Interfaces.Services;
 
 public interface ISharedFilesService
 {
-    Task AssertFilePartIsUploaded(SharedFileDefinition sharedFileDefinition, int partNumber, ICollection<string> recipients);
+    Task AssertFilePartIsUploaded(TransferParameters transferParameters, ICollection<string> recipients);
 
-    Task AssertUploadIsFinished(SharedFileDefinition sharedFileDefinition, int totalParts, ICollection<string> recipients);
+    Task AssertUploadIsFinished(TransferParameters transferParameters, ICollection<string> recipients);
 
-    Task AssertFilePartIsDownloaded(SharedFileDefinition sharedFileDefinition, Client client, int partNumber);
+    Task AssertFilePartIsDownloaded(Client client, TransferParameters transferParameters);
     
     // Task AssertDownloadIsFinished(SharedFileDefinition sharedFileDefinition, Client client);
     
diff --git a/src/ByteSync.ServerCommon/Services/SharedFilesService.cs b/src/ByteSync.ServerCommon/Services/SharedFilesService.cs
@@ -11,40 +11,56 @@ public class SharedFilesService : ISharedFilesService
 {
     private readonly ISharedFilesRepository _sharedFilesRepository;
     private readonly IBlobUrlService _blobUrlService;
+    private readonly ICloudflareR2UrlService _cloudflareR2UrlService;
     private readonly ILogger<SharedFilesService> _logger;
 
-    public SharedFilesService(ISharedFilesRepository sharedFilesRepository, IBlobUrlService blobUrlService, ILogger<SharedFilesService> logger)
+    public SharedFilesService(
+        ISharedFilesRepository sharedFilesRepository,
+        IBlobUrlService blobUrlService,
+        ICloudflareR2UrlService cloudflareR2UrlService,
+        ILogger<SharedFilesService> logger)
     {
         _sharedFilesRepository = sharedFilesRepository;
         _blobUrlService = blobUrlService;
+        _cloudflareR2UrlService = cloudflareR2UrlService;
         _logger = logger;
     }
-    public async Task AssertFilePartIsUploaded(SharedFileDefinition sharedFileDefinition, int partNumber, ICollection<string> recipients)
+    
+    public async Task AssertFilePartIsUploaded(TransferParameters transferParameters, ICollection<string> recipients)
     {
+        var sharedFileDefinition = transferParameters.SharedFileDefinition;
+        var partNumber = transferParameters.PartNumber!.Value;
+        var storageProvider = transferParameters.StorageProvider;
+        
         await _sharedFilesRepository.AddOrUpdate(sharedFileDefinition, sharedFileData =>
         {
-            sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients);
+            sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients, storageProvider);
             
             sharedFileData.UploadedPartsNumbers.Add(partNumber);
 
             return sharedFileData;
         });
     }
 
-    public async Task AssertUploadIsFinished(SharedFileDefinition sharedFileDefinition, int totalParts, ICollection<string> recipients)
+    public async Task AssertUploadIsFinished(TransferParameters transferParameters, ICollection<string> recipients)
     {
+        var sharedFileDefinition = transferParameters.SharedFileDefinition;
+        var totalParts = transferParameters.TotalParts!.Value;
+        var storageProvider = transferParameters.StorageProvider;
         await _sharedFilesRepository.AddOrUpdate(sharedFileDefinition, sharedFileData =>
         {
-            sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients);
+            sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients, storageProvider);
 
             sharedFileData.TotalParts = totalParts;
 
             return sharedFileData;
         });
     }
 
-    public async Task AssertFilePartIsDownloaded(SharedFileDefinition sharedFileDefinition, Client downloadedBy, int partNumber)
+    public async Task AssertFilePartIsDownloaded(Client downloadedBy, TransferParameters transferParameters)
     {
+        var sharedFileDefinition = transferParameters.SharedFileDefinition;
+        var partNumber = transferParameters.PartNumber!.Value;
         bool deleteBlob = false;
         bool unregister = false;
         
@@ -74,7 +90,12 @@ await _sharedFilesRepository.AddOrUpdate(sharedFileDefinition, sharedFileData =>
         {
             try
             {
-                await _blobUrlService.DeleteBlob(sharedFileDefinition, partNumber);
+                await (transferParameters.StorageProvider switch
+                {
+                    StorageProvider.AzureBlobStorage => _blobUrlService.DeleteBlob(sharedFileDefinition, partNumber),
+                    StorageProvider.CloudflareR2     => _cloudflareR2UrlService.DeleteObject(sharedFileDefinition, partNumber),
+                    _ => throw new NotSupportedException($"Storage provider {transferParameters.StorageProvider} is not supported")
+                });
             }
             catch (Exception ex)
             {
@@ -105,7 +126,12 @@ public async Task ClearSession(string sessionId)
             {
                 try
                 {
-                    await _blobUrlService.DeleteBlob(sharedFileData.SharedFileDefinition, i);
+                    await (sharedFileData.StorageProvider switch
+                    {
+                        StorageProvider.AzureBlobStorage => _blobUrlService.DeleteBlob(sharedFileData.SharedFileDefinition, i),
+                        StorageProvider.CloudflareR2     => _cloudflareR2UrlService.DeleteObject(sharedFileData.SharedFileDefinition, i),
+                        _ => throw new NotSupportedException($"Storage provider {sharedFileData.StorageProvider} is not supported")
+                    });
                 }
                 catch (Exception ex)
                 {
diff --git a/src/ByteSync.ServerCommon/Services/SynchronizationProgressService.cs b/src/ByteSync.ServerCommon/Services/SynchronizationProgressService.cs
@@ -53,7 +53,13 @@ public async Task InformSynchronizationStarted(SynchronizationEntity synchroniza
 
     public async Task UploadIsFinished(SharedFileDefinition sharedFileDefinition, int totalParts, HashSet<string> targetInstanceIds)
     {
-        await _sharedFilesService.AssertUploadIsFinished(sharedFileDefinition, totalParts, targetInstanceIds);
+        var transferParameters = new TransferParameters
+        {
+            SessionId = sharedFileDefinition.SessionId,
+            SharedFileDefinition = sharedFileDefinition,
+            TotalParts = totalParts
+        };
+        await _sharedFilesService.AssertUploadIsFinished(transferParameters, targetInstanceIds);
 
         var fileTransferPush = new FileTransferPush
         {
@@ -68,7 +74,13 @@ public async Task UploadIsFinished(SharedFileDefinition sharedFileDefinition, in
 
     public async Task FilePartIsUploaded(SharedFileDefinition sharedFileDefinition, int partNumber, HashSet<string> targetInstanceIds)
     {
-        await _sharedFilesService.AssertFilePartIsUploaded(sharedFileDefinition, partNumber, targetInstanceIds);
+        var transferParameters = new TransferParameters
+        {
+            SessionId = sharedFileDefinition.SessionId,
+            SharedFileDefinition = sharedFileDefinition,
+            PartNumber = partNumber
+        };
+        await _sharedFilesService.AssertFilePartIsUploaded(transferParameters, targetInstanceIds);
             
         var fileTransferPush = new FileTransferPush
         {
diff --git a/tests/ByteSync.ServerCommon.Tests/Commands/FileTransfers/AssertFilePartIsDownloadedCommandHandlerTests.cs b/tests/ByteSync.ServerCommon.Tests/Commands/FileTransfers/AssertFilePartIsDownloadedCommandHandlerTests.cs
@@ -34,7 +34,9 @@ public void Setup()
     }
 
     [Test]
-    public async Task Handle_ValidRequest_AssertsFilePartIsDownloaded()
+    [TestCase(StorageProvider.AzureBlobStorage)]
+    [TestCase(StorageProvider.CloudflareR2)]
+    public async Task Handle_ValidRequest_AssertsFilePartIsDownloaded(StorageProvider storageProvider)
     {
         // Arrange
         var sessionId = "session1";
@@ -46,7 +48,8 @@ public async Task Handle_ValidRequest_AssertsFilePartIsDownloaded()
         {
             SessionId = sessionId,
             SharedFileDefinition = sharedFileDefinition,
-            PartNumber = partNumber
+            PartNumber = partNumber,
+            StorageProvider = storageProvider
         };
         var request = new AssertFilePartIsDownloadedRequest(sessionId, client, transferParameters);
 
@@ -59,7 +62,7 @@ public async Task Handle_ValidRequest_AssertsFilePartIsDownloaded()
             .Returns(true);
 
         // Mock the shared files service
-        A.CallTo(() => _mockSharedFilesService.AssertFilePartIsDownloaded(sharedFileDefinition, client, partNumber))
+        A.CallTo(() => _mockSharedFilesService.AssertFilePartIsDownloaded(client, transferParameters))
             .Returns(Task.CompletedTask);
 
         // Act
@@ -70,10 +73,14 @@ public async Task Handle_ValidRequest_AssertsFilePartIsDownloaded()
             .MustHaveHappenedOnceExactly();
         A.CallTo(() => _mockTransferLocationService.IsSharedFileDefinitionAllowed(mockSessionMember, sharedFileDefinition))
             .MustHaveHappenedOnceExactly();
+        A.CallTo(() => _mockSharedFilesService.AssertFilePartIsDownloaded(client, transferParameters))
+            .MustHaveHappenedOnceExactly();
     }
 
     [Test]
-    public async Task Handle_WhenServiceThrowsException_PropagatesException()
+    [TestCase(StorageProvider.AzureBlobStorage)]
+    [TestCase(StorageProvider.CloudflareR2)]
+    public async Task Handle_WhenServiceThrowsException_PropagatesException(StorageProvider storageProvider)
     {
         // Arrange
         var sessionId = "session1";
@@ -86,7 +93,8 @@ public async Task Handle_WhenServiceThrowsException_PropagatesException()
         {
             SessionId = sessionId,
             SharedFileDefinition = sharedFileDefinition,
-            PartNumber = partNumber
+            PartNumber = partNumber,
+            StorageProvider = storageProvider
         };
         var request = new AssertFilePartIsDownloadedRequest(sessionId, client, transferParameters);
 
diff --git a/tests/ByteSync.ServerCommon.Tests/Repositories/SharedFilesRepositoryTests.cs b/tests/ByteSync.ServerCommon.Tests/Repositories/SharedFilesRepositoryTests.cs
@@ -37,7 +37,9 @@ public void SetUp()
     }
     
     [Test]
-    public async Task AddOrUpdate_IntegrationTest()
+    [TestCase(StorageProvider.AzureBlobStorage)]
+    [TestCase(StorageProvider.CloudflareR2)]
+    public async Task AddOrUpdate_IntegrationTest(StorageProvider storageProvider)
     {
         // Arrange
         var sharedFileDefinition = new SharedFileDefinition
@@ -48,7 +50,7 @@ public async Task AddOrUpdate_IntegrationTest()
 
         Func<SharedFileData?, SharedFileData> updateHandler = _ =>
         {
-            var sharedFileData = new SharedFileData(sharedFileDefinition, new List<string>());
+            var sharedFileData = new SharedFileData(sharedFileDefinition, new List<string>(), storageProvider);
 
             return sharedFileData;
         };
@@ -65,7 +67,9 @@ public async Task AddOrUpdate_IntegrationTest()
     }
     
     [Test]
-    public async Task Forget_IntegrationTest()
+    [TestCase(StorageProvider.AzureBlobStorage)]
+    [TestCase(StorageProvider.CloudflareR2)]
+    public async Task Forget_IntegrationTest(StorageProvider storageProvider)
     {
         // Arrange
         var sharedFileDefinition = new SharedFileDefinition
@@ -76,7 +80,7 @@ public async Task Forget_IntegrationTest()
 
         Func<SharedFileData?, SharedFileData> updateHandler = _ =>
         {
-            var sharedFileData = new SharedFileData(sharedFileDefinition, new List<string>());
+            var sharedFileData = new SharedFileData(sharedFileDefinition, new List<string>(), storageProvider);
 
             return sharedFileData;
         };
@@ -92,7 +96,9 @@ public async Task Forget_IntegrationTest()
     }
     
     [Test]
-    public async Task Clear_IntegrationTest()
+    [TestCase(StorageProvider.AzureBlobStorage)]
+    [TestCase(StorageProvider.CloudflareR2)]
+    public async Task Clear_IntegrationTest(StorageProvider storageProvider)
     {
         // Arrange
         var sharedFileDefinition = new SharedFileDefinition
@@ -103,7 +109,7 @@ public async Task Clear_IntegrationTest()
 
         Func<SharedFileData?, SharedFileData> updateHandler = _ =>
         {
-            var sharedFileData = new SharedFileData(sharedFileDefinition, new List<string>());
+            var sharedFileData = new SharedFileData(sharedFileDefinition, new List<string>(), storageProvider);
 
             return sharedFileData;
         };

Original file line number	Diff line number	Diff line change
`@@ -13,4 +13,6 @@ public class TransferParameters`
`13`	`13`	`public int? TotalParts { get; set; }`
`14`	`14`
`15`	`15`	`public List<string>? ActionsGroupIds { get; set; }`
	`16`	`+`
	`17`	`+ public StorageProvider StorageProvider { get; set; }`
`16`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ public SharedFileData()`
`9`	`9`	`{`
`10`	`10`
`11`	`11`	`}`
`12`		`-`
`13`		`- public SharedFileData(SharedFileDefinition sharedFileDefinition, ICollection<string> recipients)`
	`12`	`+`
	`13`	`+ public SharedFileData(SharedFileDefinition sharedFileDefinition, ICollection<string> recipients, StorageProvider storageProvider)`
`14`	`14`	`{`
`15`	`15`	`SharedFileDefinition = sharedFileDefinition;`
`16`	`16`
`@@ -24,11 +24,13 @@ public SharedFileData(SharedFileDefinition sharedFileDefinition, ICollection<str`
`24`	`24`	`{`
`25`	`25`	`cleanedData = recipient.Substring("CIID_".Length);`
`26`	`26`	`}`
`27`		`-`
	`27`	`+`
`28`	`28`	`Recipients.Add(cleanedData);`
`29`	`29`	`}`
`30`		`-`
	`30`	`+`
`31`	`31`	`DownloadedBy = new Dictionary<int, HashSet<string>>();`
	`32`	`+`
	`33`	`+ StorageProvider = storageProvider;`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`public SharedFileDefinition SharedFileDefinition { get; set; } = null!;`
`@@ -78,4 +80,6 @@ public bool IsPartFullyDownloaded(int partNumber)`
`78`	`80`
`79`	`81`	`return false;`
`80`	`82`	`}`
	`83`	`+`
	`84`	`+ public StorageProvider StorageProvider { get; set; }`
`81`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public async Task Handle(AssertFilePartIsDownloadedRequest request, Cancellation`
`31`	`31`
`32`	`32`	`if (_transferLocationService.IsSharedFileDefinitionAllowed(sessionMemberData, sharedFileDefinition))`
`33`	`33`	`{`
`34`		`- await _sharedFilesService.AssertFilePartIsDownloaded(sharedFileDefinition, request.Client, partNumber);`
	`34`	`+ await _sharedFilesService.AssertFilePartIsDownloaded(request.Client, request.TransferParameters);`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`_logger.LogDebug("File part download asserted for session {SessionId}, file {FileId}, part {PartNumber}",`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public async Task Handle(AssertFilePartIsUploadedRequest request, CancellationTo`
`51`	`51`	`{`
`52`	`52`	`var otherSessionMembers = GetOtherSessionMembers(session!, sessionMemberData);`
`53`	`53`
`54`		`- await _sharedFilesService.AssertFilePartIsUploaded(sharedFileDefinition, partNumber,`
	`54`	`+ await _sharedFilesService.AssertFilePartIsUploaded(request.TransferParameters,`
`55`	`55`	`otherSessionMembers.Select(sm => sm.ClientInstanceId).ToList());`
`56`	`56`
`57`	`57`	`var transferPush = new FileTransferPush`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public async Task Handle(AssertUploadIsFinishedRequest request, CancellationToke`
`47`	`47`	`{`
`48`	`48`	`var otherSessionMembers = GetOtherSessionMembers(session!, sessionMemberData);`
`49`	`49`
`50`		`- await _sharedFilesService.AssertUploadIsFinished(sharedFileDefinition, totalParts,`
	`50`	`+ await _sharedFilesService.AssertUploadIsFinished(request.TransferParameters,`
`51`	`51`	`otherSessionMembers.Select(sm => sm.ClientInstanceId).ToList());`
`52`	`52`
`53`	`53`	`var transferPush = new FileTransferPush`
Original file line number	Diff line number	Diff line change
`@@ -11,40 +11,56 @@ public class SharedFilesService : ISharedFilesService`
`11`	`11`	`{`
`12`	`12`	`private readonly ISharedFilesRepository _sharedFilesRepository;`
`13`	`13`	`private readonly IBlobUrlService _blobUrlService;`
	`14`	`+ private readonly ICloudflareR2UrlService _cloudflareR2UrlService;`
`14`	`15`	`private readonly ILogger<SharedFilesService> _logger;`
`15`	`16`
`16`		`- public SharedFilesService(ISharedFilesRepository sharedFilesRepository, IBlobUrlService blobUrlService, ILogger<SharedFilesService> logger)`
	`17`	`+ public SharedFilesService(`
	`18`	`+ ISharedFilesRepository sharedFilesRepository,`
	`19`	`+ IBlobUrlService blobUrlService,`
	`20`	`+ ICloudflareR2UrlService cloudflareR2UrlService,`
	`21`	`+ ILogger<SharedFilesService> logger)`
`17`	`22`	`{`
`18`	`23`	`_sharedFilesRepository = sharedFilesRepository;`
`19`	`24`	`_blobUrlService = blobUrlService;`
	`25`	`+ _cloudflareR2UrlService = cloudflareR2UrlService;`
`20`	`26`	`_logger = logger;`
`21`	`27`	`}`
`22`		`- public async Task AssertFilePartIsUploaded(SharedFileDefinition sharedFileDefinition, int partNumber, ICollection<string> recipients)`
	`28`	`+`
	`29`	`+ public async Task AssertFilePartIsUploaded(TransferParameters transferParameters, ICollection<string> recipients)`
`23`	`30`	`{`
	`31`	`+ var sharedFileDefinition = transferParameters.SharedFileDefinition;`
	`32`	`+ var partNumber = transferParameters.PartNumber!.Value;`
	`33`	`+ var storageProvider = transferParameters.StorageProvider;`
	`34`	`+`
`24`	`35`	`await _sharedFilesRepository.AddOrUpdate(sharedFileDefinition, sharedFileData =>`
`25`	`36`	`{`
`26`		`- sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients);`
	`37`	`+ sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients, storageProvider);`
`27`	`38`
`28`	`39`	`sharedFileData.UploadedPartsNumbers.Add(partNumber);`
`29`	`40`
`30`	`41`	`return sharedFileData;`
`31`	`42`	`});`
`32`	`43`	`}`
`33`	`44`
`34`		`- public async Task AssertUploadIsFinished(SharedFileDefinition sharedFileDefinition, int totalParts, ICollection<string> recipients)`
	`45`	`+ public async Task AssertUploadIsFinished(TransferParameters transferParameters, ICollection<string> recipients)`
`35`	`46`	`{`
	`47`	`+ var sharedFileDefinition = transferParameters.SharedFileDefinition;`
	`48`	`+ var totalParts = transferParameters.TotalParts!.Value;`
	`49`	`+ var storageProvider = transferParameters.StorageProvider;`
`36`	`50`	`await _sharedFilesRepository.AddOrUpdate(sharedFileDefinition, sharedFileData =>`
`37`	`51`	`{`
`38`		`- sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients);`
	`52`	`+ sharedFileData ??= new SharedFileData(sharedFileDefinition, recipients, storageProvider);`
`39`	`53`
`40`	`54`	`sharedFileData.TotalParts = totalParts;`
`41`	`55`
`42`	`56`	`return sharedFileData;`
`43`	`57`	`});`
`44`	`58`	`}`
`45`	`59`
`46`		`- public async Task AssertFilePartIsDownloaded(SharedFileDefinition sharedFileDefinition, Client downloadedBy, int partNumber)`
	`60`	`+ public async Task AssertFilePartIsDownloaded(Client downloadedBy, TransferParameters transferParameters)`
`47`	`61`	`{`
	`62`	`+ var sharedFileDefinition = transferParameters.SharedFileDefinition;`
	`63`	`+ var partNumber = transferParameters.PartNumber!.Value;`
`48`	`64`	`bool deleteBlob = false;`
`49`	`65`	`bool unregister = false;`
`50`	`66`
`@@ -74,7 +90,12 @@ await _sharedFilesRepository.AddOrUpdate(sharedFileDefinition, sharedFileData =>`
`74`	`90`	`{`
`75`	`91`	`try`
`76`	`92`	`{`
`77`		`- await _blobUrlService.DeleteBlob(sharedFileDefinition, partNumber);`
	`93`	`+ await (transferParameters.StorageProvider switch`
	`94`	`+ {`
	`95`	`+ StorageProvider.AzureBlobStorage => _blobUrlService.DeleteBlob(sharedFileDefinition, partNumber),`
	`96`	`+ StorageProvider.CloudflareR2 => _cloudflareR2UrlService.DeleteObject(sharedFileDefinition, partNumber),`
	`97`	`+ _ => throw new NotSupportedException($"Storage provider {transferParameters.StorageProvider} is not supported")`
	`98`	`+ });`
`78`	`99`	`}`
`79`	`100`	`catch (Exception ex)`
`80`	`101`	`{`
`@@ -105,7 +126,12 @@ public async Task ClearSession(string sessionId)`
`105`	`126`	`{`
`106`	`127`	`try`
`107`	`128`	`{`
`108`		`- await _blobUrlService.DeleteBlob(sharedFileData.SharedFileDefinition, i);`
	`129`	`+ await (sharedFileData.StorageProvider switch`
	`130`	`+ {`
	`131`	`+ StorageProvider.AzureBlobStorage => _blobUrlService.DeleteBlob(sharedFileData.SharedFileDefinition, i),`
	`132`	`+ StorageProvider.CloudflareR2 => _cloudflareR2UrlService.DeleteObject(sharedFileData.SharedFileDefinition, i),`
	`133`	`+ _ => throw new NotSupportedException($"Storage provider {sharedFileData.StorageProvider} is not supported")`
	`134`	`+ });`
`109`	`135`	`}`
`110`	`136`	`catch (Exception ex)`
`111`	`137`	`{`