LEGLINK-807: Implement Measure Mappings Functionality (#1807)

* Implement MeasureMapping api

* Update DMRP package lock

* Fix tests

* Coderabbit fixes

* Fix failing tests

Author: johnbritton

DotNet/DMRP/Business/Managers/MeasureMappingManager.cs

@@ -2,6 +2,9 @@
 using LantanaGroup.Link.Shared.Application.Models;
 using LantanaGroup.Link.Shared.Application.Services.Security;
 using LantanaGroup.Link.Shared.Domain.Repositories.Interfaces;
+using Microsoft.Data.SqlClient;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
 using OpenTelemetry.Trace;
 using System.Diagnostics;
 
@@ -12,6 +15,15 @@ public interface IMeasureMappingManager
         Task<MeasureMapping> CreateAsync(MeasureMapping newMeasureMapping, CancellationToken cancellationToken = default);
         Task UpdateAsync(string id, MeasureMapping measureMapping, CancellationToken cancellationToken = default);
         Task DeleteAsync(string id, CancellationToken cancellationToken = default);
+        Task DeleteAllAsync(CancellationToken cancellationToken = default);
+    }
+
+    internal sealed class DuplicateMeasureMappingException : ApplicationException
+    {
+        public DuplicateMeasureMappingException(Exception innerException)
+            : base("A measure mapping with this measure and DQM already exists.", innerException)
+        {
+        }
     }
 
     public class MeasureMappingManager : IMeasureMappingManager
@@ -38,16 +50,26 @@ public async Task<MeasureMapping> CreateAsync(MeasureMapping newMeasureMapping,
             {
                 throw;
             }
+            catch (DbUpdateException ex) when (IsUniqueIndexViolation(ex))
+            {
+                Activity.Current?.SetStatus(ActivityStatusCode.Error);
+                Activity.Current?.AddException(ex);
+                throw new DuplicateMeasureMappingException(ex);
+            }
             catch (Exception ex)
             {
                 Activity.Current?.SetStatus(ActivityStatusCode.Error);
                 Activity.Current?.AddException(ex);
-                throw new ApplicationException("Measure mapping failed to create. " + ex.Message);
+                throw new ApplicationException("Measure mapping failed to create. " + ex.Message, ex);
             }
 
             return newMeasureMapping;
         }
 
+        private static bool IsUniqueIndexViolation(DbUpdateException exception) =>
+            exception.InnerException is SqliteException { SqliteExtendedErrorCode: 2067 }
+            || exception.InnerException is SqlException { Number: 2601 or 2627 };
+
         public async Task UpdateAsync(string id, MeasureMapping measureMapping, CancellationToken cancellationToken = default)
         {
             using Activity? activity = ServiceActivitySource.Instance.StartActivity("Update Measure Mapping");
@@ -59,7 +81,9 @@ public async Task UpdateAsync(string id, MeasureMapping measureMapping, Cancella
                 throw new ApplicationException($"Measure mapping with Id: {id} not found");
             }
 
-            // TODO: Map `measureMapping` to `existing`
+            existing.Measure = measureMapping.Measure;
+            existing.DQM = measureMapping.DQM;
+            existing.Frequency = measureMapping.Frequency;
 
             try
             {
@@ -70,6 +94,12 @@ public async Task UpdateAsync(string id, MeasureMapping measureMapping, Cancella
             {
                 throw;
             }
+            catch (DbUpdateException ex) when (IsUniqueIndexViolation(ex))
+            {
+                Activity.Current?.SetStatus(ActivityStatusCode.Error);
+                Activity.Current?.AddException(ex);
+                throw new DuplicateMeasureMappingException(ex);
+            }
             catch (Exception ex)
             {
                 Activity.Current?.SetStatus(ActivityStatusCode.Error);
@@ -105,5 +135,30 @@ public async Task DeleteAsync(string id, CancellationToken cancellationToken = d
                 throw new ApplicationException($"Measure mapping {id} failed to delete. " + ex.Message);
             }
         }
+
+        public async Task DeleteAllAsync(CancellationToken cancellationToken = default)
+        {
+            using Activity? activity = ServiceActivitySource.Instance.StartActivity("Delete All Measure Mappings");
+
+            try
+            {
+                var measureMappings = await _repository.GetAllAsync(cancellationToken);
+                foreach (var measureMapping in measureMappings)
+                {
+                    _repository.Remove(measureMapping);
+                }
+                await _repository.SaveChangesAsync(cancellationToken);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                Activity.Current?.SetStatus(ActivityStatusCode.Error);
+                Activity.Current?.AddException(ex);
+                throw new ApplicationException("Failed to delete all measure mappings. " + ex.Message);
+            }
+        }
     }
 }

DotNet/DMRP/Business/Queries/MeasureMappingQueries.cs

@@ -10,8 +10,7 @@ public interface IMeasureMappingQueries
     {
         Task<MeasureMappingModel?> GetAsync(string id, CancellationToken cancellationToken = default);
 
-        Task<PagedMeasureMappingDto> PagedSearchAsync(string sortBy = "Id", SortOrder sortOrder = SortOrder.Descending,
-            int pageSize = 10, int pageNumber = 1, CancellationToken cancellationToken = default);
+        Task<PagedMeasureMappingDto> PagedSearchAsync(SearchMeasureMappingDto searchDto, CancellationToken cancellationToken = default);
     }
 
     public class MeasureMappingQueries : IMeasureMappingQueries
@@ -30,12 +29,18 @@ public MeasureMappingQueries(IEntityRepository<MeasureMapping> repository)
             return entity == null ? null : ToModel(entity);
         }
 
-        public async Task<PagedMeasureMappingDto> PagedSearchAsync(string sortBy = "Id",
-            SortOrder sortOrder = SortOrder.Descending, int pageSize = 10, int pageNumber = 1,
-            CancellationToken cancellationToken = default)
+        public async Task<PagedMeasureMappingDto> PagedSearchAsync(SearchMeasureMappingDto searchDto, CancellationToken cancellationToken = default)
         {
-            var (records, metadata) = await _repository.SearchAsync(m => true, sortBy, sortOrder,
-                pageSize, pageNumber, cancellationToken);
+            var measure = string.IsNullOrWhiteSpace(searchDto.Measure) ? null : searchDto.Measure;
+            var dqm = string.IsNullOrWhiteSpace(searchDto.DQM) ? null : searchDto.DQM;
+            var frequency = searchDto.Frequency;
+
+            var (records, metadata) = await _repository.SearchAsync(
+                m => (measure == null || m.Measure == measure)
+                    && (dqm == null || m.DQM == dqm)
+                    && (!frequency.HasValue || m.Frequency == frequency.Value),
+                searchDto.SortBy, searchDto.SortOrder,
+                searchDto.PageSize, searchDto.PageNumber, cancellationToken);
 
             return new PagedMeasureMappingDto
             {
@@ -44,6 +49,12 @@ public async Task<PagedMeasureMappingDto> PagedSearchAsync(string sortBy = "Id",
             };
         }
 
-        private static MeasureMappingModel ToModel(MeasureMapping entity) => new() { Id = entity.Id };
+        private static MeasureMappingModel ToModel(MeasureMapping entity) => new()
+        {
+            Id = entity.Id,
+            Measure = entity.Measure,
+            DQM = entity.DQM,
+            Frequency = entity.Frequency
+        };
     }
 }

DotNet/DMRP/Controllers/MeasureMappingsController.cs

@@ -3,14 +3,17 @@
 using LantanaGroup.Link.DMRP.Data.Entities;
 using LantanaGroup.Link.DMRP.Models;
 using LantanaGroup.Link.Shared.Application.Enums;
+using LantanaGroup.Link.Shared.Application.Filters;
 using LantanaGroup.Link.Shared.Application.Models;
 using LantanaGroup.Link.Shared.Application.Models.Integration.DMRP;
 using LantanaGroup.Link.Shared.Application.Services.Security;
+using LantanaGroup.Link.Sdk.Clients;
 using Link.Authorization.Policies;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using OpenTelemetry.Trace;
 using System.Diagnostics;
+using System.Net;
 
 namespace LantanaGroup.Link.DMRP.Controllers
 {
@@ -22,12 +25,18 @@ public class MeasureMappingsController : ControllerBase
         private readonly ILogger<MeasureMappingsController> _logger;
         private readonly IMeasureMappingManager _manager;
         private readonly IMeasureMappingQueries _queries;
+        private readonly IMeasureEvalServiceClient _measureEvalClient;
 
-        public MeasureMappingsController(ILogger<MeasureMappingsController> logger, IMeasureMappingManager manager, IMeasureMappingQueries queries)
+        public MeasureMappingsController(
+            ILogger<MeasureMappingsController> logger,
+            IMeasureMappingManager manager,
+            IMeasureMappingQueries queries,
+            IMeasureEvalServiceClient measureEvalClient)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _manager = manager ?? throw new ArgumentNullException(nameof(manager));
             _queries = queries ?? throw new ArgumentNullException(nameof(queries));
+            _measureEvalClient = measureEvalClient ?? throw new ArgumentNullException(nameof(measureEvalClient));
         }
 
         /// <summary>
@@ -36,26 +45,14 @@ public MeasureMappingsController(ILogger<MeasureMappingsController> logger, IMea
         [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(PagedMeasureMappingDto))]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        [HttpGet(Name = "GetMeasureMappings")]
-        public async Task<IActionResult> GetMeasureMappings(string? sortBy, SortOrder? sortOrder,
-            int pageSize = 10, int pageNumber = 1, CancellationToken cancellationToken = default)
+        [HttpGet("search")]
+        public async Task<IActionResult> GetMeasureMappings([FromQuery] SearchMeasureMappingDto searchDto, CancellationToken cancellationToken = default)
         {
-            sortBy = sortBy?.Sanitize();
-
-            if (pageSize < 1 || pageSize > 100)
-            {
-                pageSize = 10;
-            }
-
-            if (pageNumber < 1)
-            {
-                pageNumber = 1;
-            }
+            searchDto.Sanitize();
 
             using Activity? activity = ServiceActivitySource.Instance.StartActivity("Get Measure Mappings");
 
-            var result = await _queries.PagedSearchAsync(sortBy ?? "Id", sortOrder ?? SortOrder.Descending,
-                pageSize, pageNumber, cancellationToken);
+            var result = await _queries.PagedSearchAsync(searchDto, cancellationToken);
 
             if (result.Records.Count == 0)
             {
@@ -91,30 +88,47 @@ public async Task<IActionResult> GetMeasureMapping(string id, CancellationToken
         /// </summary>
         [ProducesResponseType(StatusCodes.Status201Created, Type = typeof(MeasureMappingModel))]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status502BadGateway, Type = typeof(ProblemDetails))]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ValidateAntiForgeryOrBearerToken]
         [HttpPost]
         public async Task<IActionResult> CreateMeasureMapping(MeasureMappingModel request, CancellationToken cancellationToken)
         {
             MeasureMapping created;
 
             try
             {
-                var entity = new MeasureMapping();
-                // TODO: Map `request` to `entity`
+                var entity = ToEntity(request);
+                if (!await DqmExistsAsync(entity.DQM, cancellationToken))
+                {
+                    return BadRequest($"DQM '{entity.DQM}' was not found in MeasureEval.");
+                }
+
                 created = await _manager.CreateAsync(entity, cancellationToken);
             }
-            catch (ApplicationException ex)
+            catch (DuplicateMeasureMappingException)
+            {
+                return ValidationProblem(new ValidationProblemDetails(new Dictionary<string, string[]>
+                {
+                    ["measure"] = ["A measure mapping for this measure and dQM already exists."]
+                }));
+            }
+            catch (ApplicationException)
+            {
+                return BadRequest();
+            }
+            catch (HttpRequestException ex)
             {
-                return BadRequest(ex.Message);
+                _logger.LogError(ex, "MeasureEval failed while verifying the DQM for a measure mapping.");
+                return Problem("Unable to verify the DQM in MeasureEval.", statusCode: StatusCodes.Status502BadGateway);
             }
             catch (Exception ex)
             {
                 _logger.LogError(ex, "Exception encountered in MeasureMappingsController.CreateMeasureMapping");
                 return Problem("An error occurred while creating the measure mapping", null, 500);
             }
 
-            var model = new MeasureMappingModel { Id = created.Id };
-            // TODO: Map `created` to `model`
+            var model = ToModel(created);
 
             return Created($"/api/dmrp/measure-mappings/{model.Id}", model);
         }
@@ -125,7 +139,9 @@ public async Task<IActionResult> CreateMeasureMapping(MeasureMappingModel reques
         [ProducesResponseType(StatusCodes.Status202Accepted, Type = typeof(MeasureMappingModel))]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status502BadGateway, Type = typeof(ProblemDetails))]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ValidateAntiForgeryOrBearerToken]
         [HttpPut("{id}")]
         public async Task<IActionResult> UpdateMeasureMapping(string id, MeasureMappingModel request, CancellationToken cancellationToken)
         {
@@ -138,12 +154,32 @@ public async Task<IActionResult> UpdateMeasureMapping(string id, MeasureMappingM
 
             try
             {
-                await _manager.UpdateAsync(id, new MeasureMapping { Id = id }, cancellationToken);
+                var entity = ToEntity(request);
+                entity.Id = id;
+
+                if (!await DqmExistsAsync(entity.DQM, cancellationToken))
+                {
+                    return BadRequest($"DQM '{entity.DQM}' was not found in MeasureEval.");
+                }
+
+                await _manager.UpdateAsync(id, entity, cancellationToken);
+            }
+            catch (DuplicateMeasureMappingException)
+            {
+                return ValidationProblem(new ValidationProblemDetails(new Dictionary<string, string[]>
+                {
+                    ["measure"] = ["A measure mapping for this measure and dQM already exists."]
+                }));
             }
             catch (ApplicationException ex)
             {
                 return NotFound(ex.Message);
             }
+            catch (HttpRequestException ex)
+            {
+                _logger.LogError(ex, "MeasureEval failed while verifying the DQM for a measure mapping.");
+                return Problem("Unable to verify the DQM in MeasureEval.", statusCode: StatusCodes.Status502BadGateway);
+            }
             catch (Exception ex)
             {
                 _logger.LogError(ex, "Exception encountered in MeasureMappingsController.UpdateMeasureMapping");
@@ -182,5 +218,60 @@ public async Task<IActionResult> DeleteMeasureMapping(string id, CancellationTok
 
             return NoContent();
         }
+
+        /// <summary>
+        /// Deletes all measure mappings.
+        /// </summary>
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ValidateAntiForgeryOrBearerToken]
+        [HttpDelete]
+        public async Task<IActionResult> DeleteAllMeasureMappings(CancellationToken cancellationToken)
+        {
+            try
+            {
+                await _manager.DeleteAllAsync(cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Exception encountered in MeasureMappingsController.DeleteAllMeasureMappings");
+                return Problem("An error occurred while deleting the measure mappings", null, 500);
+            }
+
+            return NoContent();
+        }
+
+        private static MeasureMapping ToEntity(MeasureMappingModel model) => new()
+        {
+            Measure = model.Measure?.Sanitize() ?? "",
+            DQM = model.DQM?.Sanitize() ?? "",
+            Frequency = model.Frequency ?? Frequency.Adhoc
+        };
+
+        private static MeasureMappingModel ToModel(MeasureMapping entity) => new()
+        {
+            Id = entity.Id,
+            Measure = entity.Measure,
+            DQM = entity.DQM,
+            Frequency = entity.Frequency
+        };
+
+        private async Task<bool> DqmExistsAsync(string dqm, CancellationToken cancellationToken)
+        {
+            var response = await _measureEvalClient.GetMeasureDefinitionAsync(dqm, cancellationToken);
+
+            if (response.StatusCode == StatusCodes.Status404NotFound)
+            {
+                return false;
+            }
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"MeasureEval returned status code {response.StatusCode} while verifying a DQM.", null, (HttpStatusCode)response.StatusCode);
+            }
+
+            return true;
+        }
     }
 }

DotNet/DMRP/DMRP.csproj

@@ -31,6 +31,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
+		<ProjectReference Include="..\LinkSdk\LinkSdk.csproj" />
 		<ProjectReference Include="..\Shared\Shared.csproj" />
 	</ItemGroup>