From d6b3f5e876c8cb9a9a16d3560c3b45b4007634de Mon Sep 17 00:00:00 2001
From: Michael Clayson <michael.clayson1@nhs.net>
Date: Tue, 4 Mar 2025 10:54:59 +0000
Subject: [PATCH] fix: execution policy wrapper

---
 .../DataServices.Core/DataServiceAccessor.cs  | 108 ++++++++++--------
 1 file changed, 60 insertions(+), 48 deletions(-)

diff --git a/application/CohortManager/src/Functions/Shared/DataServices.Core/DataServiceAccessor.cs b/application/CohortManager/src/Functions/Shared/DataServices.Core/DataServiceAccessor.cs
index 1bef4104ed..629435f0e4 100644
--- a/application/CohortManager/src/Functions/Shared/DataServices.Core/DataServiceAccessor.cs
+++ b/application/CohortManager/src/Functions/Shared/DataServices.Core/DataServiceAccessor.cs
@@ -37,69 +37,81 @@ public async Task<bool> InsertSingle(TEntity entity)
 
     public async Task<bool> InsertMany(IEnumerable<TEntity> entities)
     {
-        using var transaction = await _context.Database.BeginTransactionAsync();
+        var strategy = _context.Database.CreateExecutionStrategy();
+        var result = await strategy.ExecuteAsync( async () =>
+        {
+            using var transaction = await _context.Database.BeginTransactionAsync();
 
-        await _context.AddRangeAsync(entities);
-        var result = await _context.SaveChangesAsync();
+            await _context.AddRangeAsync(entities);
+            var result = await _context.SaveChangesAsync();
 
-        await transaction.CommitAsync();
-        return result > 0;
+            await transaction.CommitAsync();
+            return result > 0;
+        });
+        return result;
     }
 
     public async Task<bool> Remove(Expression<Func<TEntity, bool>> predicate)
     {
-
-        using var transaction = await _context.Database.BeginTransactionAsync();
-        var result = await _context.Set<TEntity>().AsNoTracking().SingleOrDefaultAsync(predicate);
-
-        if (result == null)
-        {
-            return false;
-        }
-        _context.Set<TEntity>().Remove(result);
-        var rowsEffected =  await _context.SaveChangesAsync();
-        if(rowsEffected > 1)
+        var strategy = _context.Database.CreateExecutionStrategy();
+        var result = await strategy.ExecuteAsync( async () =>
         {
-            await _context.Database.RollbackTransactionAsync();
+            using var transaction = await _context.Database.BeginTransactionAsync();
+            var result = await _context.Set<TEntity>().AsNoTracking().SingleOrDefaultAsync(predicate);
+
+            if (result == null)
+            {
+                return false;
+            }
+            _context.Set<TEntity>().Remove(result);
+            var rowsEffected =  await _context.SaveChangesAsync();
+            if(rowsEffected > 1)
+            {
+                await _context.Database.RollbackTransactionAsync();
+
+                _logger.LogError("There was an error while trying to deleted despite a record being found");
+                throw new MultipleRecordsFoundException("Multiple Records were updated by PUT request, Changes have been Rolled-back");
+            }
 
-            _logger.LogError("There was an error while trying to deleted despite a record being found");
-            throw new MultipleRecordsFoundException("Multiple Records were updated by PUT request, Changes have been Rolled-back");
-        }
-
-        await _context.Database.CommitTransactionAsync();
-        return true;
+            await _context.Database.CommitTransactionAsync();
+            return true;
+        });
+        return result;
 
     }
 
     public async Task<TEntity> Update(TEntity entity, Expression<Func<TEntity, bool>> predicate)
     {
-
-
-        using var transaction = await _context.Database.BeginTransactionAsync();
-
-        var existingEntity = await _context.Set<TEntity>().AsNoTracking().SingleOrDefaultAsync(predicate);
-
-        if (existingEntity == null)
+        var strategy = _context.Database.CreateExecutionStrategy();
+        var result = await strategy.ExecuteAsync( async () =>
         {
-            return null;
-        }
-        _context.Update(entity);
-        var rowsEffected  = await _context.SaveChangesAsync();
-
-
-        if (rowsEffected == 1)
-        {
-            await _context.Database.CommitTransactionAsync();
-            return entity;
-        }
-        else if (rowsEffected > 1)
-        {
-            await transaction.RollbackAsync();
-            _logger.LogError("Multiple Records were updated by PUT request, Changes have been Rolled-back");
+            using var transaction = await _context.Database.BeginTransactionAsync();
+
+            var existingEntity = await _context.Set<TEntity>().AsNoTracking().SingleOrDefaultAsync(predicate);
+
+            if (existingEntity == null)
+            {
+                return null;
+            }
+            _context.Update(entity);
+            var rowsEffected  = await _context.SaveChangesAsync();
+
+
+            if (rowsEffected == 1)
+            {
+                await _context.Database.CommitTransactionAsync();
+                return entity;
+            }
+            else if (rowsEffected > 1)
+            {
+                await transaction.RollbackAsync();
+                _logger.LogError("Multiple Records were updated by PUT request, Changes have been Rolled-back");
+                throw new MultipleRecordsFoundException("Multiple Records were updated by PUT request, Changes have been Rolled-back");
+            }
+            _logger.LogError("No records were updated despite a record being found");
             throw new MultipleRecordsFoundException("Multiple Records were updated by PUT request, Changes have been Rolled-back");
-        }
-        _logger.LogError("No records were updated despite a record being found");
-        throw new MultipleRecordsFoundException("Multiple Records were updated by PUT request, Changes have been Rolled-back");
+        });
+        return result;
     }
 
 }