Add DutyCompletionRecords API

Expedience.Api/Controllers/ExpedienceController.cs

@@ -2,7 +2,6 @@
 using System.Text.Json;
 using Expedience.Api.Encryption;
 using Expedience.Infrastructure;
-using Expedience.Infrastructure.Concurrency;
 using MassTransit;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
@@ -16,19 +15,16 @@ namespace Expedience.Api.Controllers
         private readonly ILogger<ExpedienceController> _logger;
         private readonly IPublishEndpoint _publisher;
         private readonly IDecryptor _decrypytor;
-        private readonly IDistributedLock _distributedLock;
         private readonly IServiceScopeFactory _serviceScopeFactory;
 
         public ExpedienceController(ILogger<ExpedienceController> logger,
             IPublishEndpoint publisher,
             IDecryptor decrypytor,
-            IDistributedLock distributedLock,
             IServiceScopeFactory serviceScopeFactory)
         {
             _logger = logger;
             _publisher = publisher;
             _decrypytor = decrypytor;
-            _distributedLock = distributedLock;
             _serviceScopeFactory = serviceScopeFactory;
         }
 
@@ -54,6 +50,25 @@ namespace Expedience.Api.Controllers
             return Ok();
         }
 
+        [HttpGet("DutyCompletionRecords/{expac}")]
+        public async Task<ActionResult> GetDutyCompletionRecords(string expac, CancellationToken cancellationToken)
+        {
+            try
+            {
+                using var scope = _serviceScopeFactory.CreateScope();
+                using var repository = scope.ServiceProvider.GetService<IRepository>();
+
+                var results = repository.GetDutyCompletionRecords(expac, CancellationToken.None);
+                return Ok(results);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error getting Duty Completion Records for {expac}: {errorMessage}", expac, ex.Message);
+            }
+
+            return Ok();
+        }
+
         [HttpGet("UserName/{worldId}/{userHash}")]
         public async Task<ActionResult> GetUserName(int worldId, string userHash, CancellationToken cancellationToken)
         {

Expedience.Api/Program.cs

@@ -35,6 +35,7 @@ builder.Services.AddMassTransit(opt =>
 });
 
 builder.Services.AddEnyimMemcached();
+builder.Services.AddScoped<IRepository, ExpedienceRepository>();
 
 builder.Services.AddSingleton<IDistributedLock, DistributedLock>();
 builder.Services.AddSingleton<IDecryptor, Decryptor>();

Expedience.Infrastructure/ExpedienceContext.cs

@@ -17,6 +17,7 @@ namespace Expedience.Infrastructure
         public DbSet<Territory> Territories { get; set; }
 
         public DbSet<User> Users { get; set; }
+        public DbSet<DutyCompletionRecord> DutyCompletionRecords { get; set; }
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
@@ -66,6 +67,10 @@ namespace Expedience.Infrastructure
                 cfg.HasKey(e => new { e.TerritoryId });
             });
 
+            modelBuilder.Entity<DutyCompletionRecord>()
+                .HasNoKey()
+                .ToTable(t => t.ExcludeFromMigrations());
+
             base.OnModelCreating(modelBuilder);
         }
     }

Expedience.Infrastructure/ExpedienceRepository.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using Enyim.Caching;
+using Expedience.Infrastructure.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Expedience.Infrastructure
+{
+    public interface IRepository : IDisposable
+    {
+        Task<List<DutyCompletionRecord>> GetDutyCompletionRecords(string expac, CancellationToken cancellationToken);
+    }
+
+    public class ExpedienceRepository : IRepository
+    {
+        private readonly ExpedienceContext _dbContext;
+        private readonly IMemcachedClient _memcachedClient;
+
+        public ExpedienceRepository(ExpedienceContext dbContext, IMemcachedClient memcachedClient)
+        {
+            _dbContext = dbContext;
+            _memcachedClient = memcachedClient;
+        }
+
+        public async Task<List<DutyCompletionRecord>> GetDutyCompletionRecords(string expac, CancellationToken cancellationToken)
+        {
+            var cacheKey = $"xpd-dcr-{expac}";
+            if (_memcachedClient.TryGet<List<DutyCompletionRecord>>(cacheKey, out var cachedValue))
+            {
+                return cachedValue;
+            }
+            else
+            {
+                var records = await _dbContext.DutyCompletionRecords.FromSqlInterpolated($"CALL get_dutycompletionrecords {expac}")
+                    .ToListAsync();
+
+                await _memcachedClient.AddAsync(cacheKey, records, TimeSpan.FromMinutes(10));
+
+                return records;
+            }
+        }
+
+        public void Dispose()
+        {
+            _dbContext.Dispose();
+        }
+    }
+}

Expedience.Infrastructure/Models/DutyCompletionRecord.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Expedience.Infrastructure.Models
+{
+    public class DutyCompletionRecord
+    {
+        public int TerritoryId { get; set; }
+        public string ContentName { get; set; }
+        public string ContentType { get; set; }
+        public int Level { get; set; }
+        public TimeSpan? MinTime { get; set; }
+        public TimeSpan? AverageTime { get; set; }
+    }
+}