Add caching to event data

Author: dynamictulip

PocketDDD.BlazorClient/PocketDDD.BlazorClient/Services/FakePocketDDDApiService.cs

@@ -25,6 +25,7 @@ public void SetUserAuthToken(string token)
         return
             new EventDataResponseDTO
             {
+                Id = 1,
                 Version = 1,
                 TimeSlots = new[]
                 {

PocketDDD.Server/PocketDDD.Server.Services/EventDataService.cs

@@ -1,63 +1,79 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
 using PocketDDD.Server.DB;
-using PocketDDD.Server.Model.DTOs;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using PocketDDD.Shared.API.RequestDTOs;
 using PocketDDD.Shared.API.ResponseDTOs;
 
 namespace PocketDDD.Server.Services;
-public class EventDataService
+
+public class EventDataService(PocketDDDContext dbContext, IMemoryCache memoryCache, ILogger<EventDataService> logger)
 {
-    private readonly PocketDDDContext dbContext;
+    private const string FetchLatestEventDataCacheKey = nameof(FetchLatestEventData);
+    private const string FetchCurrentEventDetailIdCacheKey = nameof(FetchCurrentEventDetailId);
 
-    public EventDataService(PocketDDDContext dbContext)
+    public async Task<int> FetchCurrentEventDetailId()
     {
-        this.dbContext = dbContext;
+        if (memoryCache.TryGetValue<int?>(FetchCurrentEventDetailIdCacheKey, out var cachedEventDetailId))
+            return cachedEventDetailId!.Value;
+
+        cachedEventDetailId = await dbContext.EventDetail.MaxAsync(e => e.Id);
+        memoryCache.Set(FetchCurrentEventDetailIdCacheKey, cachedEventDetailId, TimeSpan.FromMinutes(5));
+
+        return cachedEventDetailId.Value;
     }
 
-    public async Task<EventDataResponseDTO?> FetchLatestEventData(EventDataUpdateRequestDTO requestDTO)
+    public async Task<EventDataResponseDTO?> FetchLatestEventData(EventDataUpdateRequestDTO requestDto)
     {
-        var eventDetails = await dbContext.EventDetail
-                                          .Include(x => x.TimeSlots)
-                                          .Include(x => x.Tracks)
-                                          .Include(x => x.Sessions)
-                                          .SingleAsync(x => x.Id == 1);
-            
-        if (requestDTO.Version == eventDetails!.Version)
+        var currentEventDetailId = await FetchCurrentEventDetailId();
+        
+        if (memoryCache.TryGetValue<EventDataResponseDTO?>(FetchLatestEventDataCacheKey, out var latestEventData))
+        {
+            logger.LogDebug("Retrieved latest event data from the cache {eventData}", latestEventData);
+        }
+        else
+        {
+            logger.LogDebug("No event data in the cache, retrieving from the db");
+            latestEventData = await dbContext.EventDetail
+                .AsNoTracking()
+                .AsSingleQuery()
+                .Select(eventDetails => new EventDataResponseDTO
+                {
+                    Id = eventDetails.Id,
+                    Version = eventDetails.Version,
+                    TimeSlots = eventDetails.TimeSlots.Select(ts => new TimeSlotDTO
+                    {
+                        Id = ts.Id,
+                        Info = ts.Info,
+                        From = ts.From,
+                        To = ts.To
+                    }).ToList(),
+                    Tracks = eventDetails.Tracks.Select(t => new TrackDTO
+                    {
+                        Id = t.Id,
+                        Name = t.Name,
+                        RoomName = t.RoomName
+                    }).ToList(),
+                    Sessions = eventDetails.Sessions.Select(s => new SessionDTO
+                    {
+                        Id = s.Id,
+                        Title = s.Title,
+                        ShortDescription = s.ShortDescription,
+                        FullDescription = s.FullDescription,
+                        Speaker = s.Speaker,
+                        TimeSlotId = s.TimeSlot.Id,
+                        TrackId = s.Track.Id
+                    }).ToList()
+                })
+                .SingleAsync(e => e.Id == currentEventDetailId);
+
+            memoryCache.Set(FetchLatestEventDataCacheKey, latestEventData, TimeSpan.FromMinutes(5));
+            logger.LogDebug("Updated the latest event data in the cache {eventData}", latestEventData);
+        }
+
+        if (requestDto.Version >= latestEventData!.Version)
             return null;
 
-        var dtoResponse = new EventDataResponseDTO
-        {
-            Version = eventDetails.Version,
-            TimeSlots = eventDetails.TimeSlots.Select(ts => new TimeSlotDTO
-            {
-                Id = ts.Id,
-                Info = ts.Info,
-                From = ts.From,
-                To = ts.To
-            }).ToList(),
-            Tracks = eventDetails.Tracks.Select(t => new TrackDTO
-            {
-                Id = t.Id,
-                Name = t.Name,
-                RoomName = t.RoomName
-            }).ToList(),
-            Sessions = eventDetails.Sessions.Select(s => new SessionDTO
-            {
-                Id = s.Id,
-                Title = s.Title,
-                ShortDescription = s.ShortDescription,
-                FullDescription = s.FullDescription,
-                Speaker = s.Speaker,
-                TimeSlotId = s.TimeSlot.Id,
-                TrackId = s.Track.Id
-            }).ToList()
-        };
-
-        return dtoResponse;
+        return latestEventData;
     }
 }

PocketDDD.Server/PocketDDD.Server.WebAPI/Program.cs

@@ -29,6 +29,8 @@
     options => options.UseSqlServer("name=ConnectionStrings:PocketDDDContext")
 );
 
+builder.Services.AddMemoryCache();
+
 builder.Services.AddScoped<RegistrationService>();
 builder.Services.AddScoped<UserService>();
 builder.Services.AddScoped<FeedbackService>();

PocketDDD.Shared/API/ResponseDTOs/EventDataResponseDTO.cs

@@ -1,12 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+namespace PocketDDD.Shared.API.ResponseDTOs;
 
-namespace PocketDDD.Shared.API.ResponseDTOs;
 public record EventDataResponseDTO
 {
+    public int Id { get; init; }
     public int Version { get; set; }
     public IEnumerable<TimeSlotDTO> TimeSlots { get; set; } = Enumerable.Empty<TimeSlotDTO>();
     public IEnumerable<TrackDTO> Tracks { get; set; } = Enumerable.Empty<TrackDTO>();
@@ -37,4 +33,4 @@ public class SessionDTO
     public string Speaker { get; set; } = "";
     public int TrackId { get; set; }
     public int TimeSlotId { get; set; }
-}
+}