Add transaction to blocking Provider

OutOfSchool/OutOfSchool.DataAccess/Repository/EntityRepositoryBase.cs

@@ -77,6 +77,28 @@ public virtual async Task<T> RunInTransaction<T>(Func<Task<T>> operation)
             });
     }
 
+    /// <inheritdoc/>
+    public virtual async Task RunInTransaction(Func<Task> operation)
+    {
+        var executionStrategy = dbContext.Database.CreateExecutionStrategy();
+
+        await executionStrategy.ExecuteAsync(
+            async () =>
+            {
+                await using IDbContextTransaction transaction = await dbContext.Database.BeginTransactionAsync();
+                try
+                {
+                    await operation().ConfigureAwait(false);
+                    await transaction.CommitAsync().ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    await transaction.RollbackAsync().ConfigureAwait(false);
+                    throw;
+                }
+            });
+    }
+
     /// <inheritdoc/>
     public virtual async Task Delete(TEntity entity)
     {

OutOfSchool/OutOfSchool.DataAccess/Repository/IEntityRepository.cs

@@ -43,6 +43,13 @@ public interface IEntityRepositoryBase<TKey, TEntity>
     /// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns>
     Task<T> RunInTransaction<T>(Func<Task<T>> operation);
 
+    /// <summary>
+    /// Runs operation in transaction without result.
+    /// </summary>
+    /// <param name="operation">Method that represents the operation.</param>
+    /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+    Task RunInTransaction(Func<Task> operation);
+
     /// <summary>
     /// Update information about element.
     /// </summary>

OutOfSchool/OutOfSchool.WebApi.Tests/Services/ProviderServiceTests.cs

@@ -939,6 +939,8 @@ public async Task Block_ReturnsProviderBlockDto_IfDtoIsValid()
             .ReturnsAsync(provider);
         providersRepositoryMock.Setup(r => r.UnitOfWork.CompleteAsync())
             .ReturnsAsync(It.IsAny<int>());
+        providersRepositoryMock.Setup(r => r.RunInTransaction(It.IsAny<Func<Task<ProviderBlockDto>>>()))
+            .ReturnsAsync(providerBlockDto);
 
         // Act
         var result = await providerService.Block(providerBlockDto).ConfigureAwait(false);

OutOfSchool/OutOfSchool.WebApi/Services/ProviderService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
@@ -303,20 +304,23 @@ public async Task<ProviderBlockDto> Block(ProviderBlockDto providerBlockDto)
         // TODO: validate if current user has permission to block/unblock the provider
         provider.IsBlocked = providerBlockDto.IsBlocked;
         provider.BlockReason = providerBlockDto.IsBlocked ? providerBlockDto.BlockReason : null;
-        await providerRepository.UnitOfWork.CompleteAsync().ConfigureAwait(false);
-
-        // TODO What's happen if previous action will not successfull?
-        var workshops = await workshopServiceCombiner
-                           .BlockByProvider(provider)
-                           .ConfigureAwait(false);
 
-        foreach (var workshop in workshops)
+        await providerRepository.RunInTransaction(async () =>
         {
-            logger.LogInformation($"IsBlocked property with povider Id = {provider.Id} " +
-                                  $"in workshops with Id = {workshop.Id} updated successfully.");
-        }
+            await providerRepository.UnitOfWork.CompleteAsync().ConfigureAwait(false);
+
+            var workshops = await workshopServiceCombiner
+                               .BlockByProvider(provider)
+                               .ConfigureAwait(false);
+
+            foreach (var workshop in workshops)
+            {
+                logger.LogInformation($"IsBlocked property with povider Id = {provider.Id} " +
+                                      $"in workshops with Id = {workshop.Id} updated successfully.");
+            }
 
-        logger.LogInformation($"Provider(id) {providerBlockDto.Id} IsBlocked was changed to {provider.IsBlocked}");
+            logger.LogInformation($"Provider(id) {providerBlockDto.Id} IsBlocked was changed to {provider.IsBlocked}");
+        });
 
         return providerBlockDto;
     }