✨ Add caching service and cached leaderboard, and user rankings

src/Application/Achievements/Command/ClaimAchievementForUser/ClaimAchievementForUserCommand.cs

@@ -12,13 +12,16 @@ public class ClaimAchievementForUserCommand : IRequest<ClaimAchievementResult>
 public class ClaimAchievementForUserCommandHandler : IRequestHandler<ClaimAchievementForUserCommand, ClaimAchievementResult>
 {
     private readonly IApplicationDbContext _context;
+    private readonly ICacheService _cacheService;
     private readonly ILogger<ClaimAchievementForUserCommand> _logger;
 
     public ClaimAchievementForUserCommandHandler(
             IApplicationDbContext context,
+            ICacheService cacheService,
             ILogger<ClaimAchievementForUserCommand> logger)
     {
         _context = context;
+        _cacheService = cacheService;
         _logger = logger;
     }
 
@@ -31,7 +34,7 @@ public async Task<ClaimAchievementResult> Handle(ClaimAchievementForUserCommand
 
         if (achievement == null)
         {
-            _logger.LogError("Achievement was not found for code: {0}", request.Code);
+            _logger.LogError("Achievement was not found for code: {AchievementCode}", request.Code);
             return new ClaimAchievementResult
             {
                 status = ClaimAchievementStatus.NotFound
@@ -45,7 +48,7 @@ public async Task<ClaimAchievementResult> Handle(ClaimAchievementForUserCommand
 
         if (user == null)
         {
-            _logger.LogError("User was not found for id: {0}", request.UserId);
+            _logger.LogError("User was not found for id: {UserId}", request.UserId);
             return new ClaimAchievementResult
             {
                 status = ClaimAchievementStatus.Error
@@ -59,7 +62,7 @@ public async Task<ClaimAchievementResult> Handle(ClaimAchievementForUserCommand
 
         if (achievementCheck != null)
         {
-            _logger.LogError("User already has achievement: {0}", request.Code);
+            _logger.LogError("User already has achievement: {AchievementCode}", request.Code);
             return new ClaimAchievementResult
             {
                 status = ClaimAchievementStatus.Duplicate
@@ -68,19 +71,20 @@ public async Task<ClaimAchievementResult> Handle(ClaimAchievementForUserCommand
 
         try
         {
-            await _context
-                .UserAchievements
-                .AddAsync(new UserAchievement
+            _context.UserAchievements
+                .Add(new UserAchievement
                 {
                     UserId = user.Id,
                     AchievementId = achievement.Id
-                }, cancellationToken);
+                });
 
             await _context.SaveChangesAsync(cancellationToken);
+
+            _cacheService.Remove(CacheTags.UpdatedRanking);
         }
         catch (Exception e)
         {
-            _logger.LogError(e.Message, e);
+            _logger.LogError(e, "Unable to claim achievement {AchievementId} for User {UserId} with error {ErrorMessage}", achievement.Id, user.Id, e.Message);
             return new ClaimAchievementResult
             {
                 status = ClaimAchievementStatus.Error

src/Application/Achievements/Command/ClaimFormCompletedAchievement/ClaimFormCompletedAchievementCommand.cs

@@ -12,12 +12,14 @@ public class ClaimFormCompletedAchievementCommand : IRequest
 public class ClaimFormCompletedAchievementCommandHandler : IRequestHandler<ClaimFormCompletedAchievementCommand>
 {
     private readonly IEmailService _emailService;
+    private readonly ICacheService _cacheService;
     private readonly IApplicationDbContext _dbContext;
 
-    public ClaimFormCompletedAchievementCommandHandler(IApplicationDbContext dbContext, IEmailService emailService)
+    public ClaimFormCompletedAchievementCommandHandler(IApplicationDbContext dbContext, IEmailService emailService, ICacheService cacheService)
     {
         _dbContext = dbContext;
         _emailService = emailService;
+        _cacheService = cacheService;
     }
 
     public async Task Handle(ClaimFormCompletedAchievementCommand request, CancellationToken cancellationToken)
@@ -76,6 +78,8 @@ await _emailService.SendFormCompletionCreateAccountEmail(request.Email.ToLower()
             }
 
             await _dbContext.SaveChangesAsync(cancellationToken);
+
+            _cacheService.Remove(CacheTags.UpdatedRanking);
         }
     }
 }

src/Application/Achievements/Command/ClaimSocialMediaAchievementForUser/ClaimSocialMediaAchievementForUserCommand.cs

@@ -10,14 +10,16 @@ public sealed class ClaimSocialMediaAchievementForUserCommandHandler : IRequestH
     private readonly IApplicationDbContext _context;
     private readonly ICurrentUserService _currentUserService;
     private readonly IUserService _userService;
+    private readonly ICacheService _cacheService;
     private readonly IDateTime _dateTimeService;
 
-    public ClaimSocialMediaAchievementForUserCommandHandler(IApplicationDbContext context, ICurrentUserService currentUserService, IUserService userService, IDateTime dateTimeService)
+    public ClaimSocialMediaAchievementForUserCommandHandler(IApplicationDbContext context, ICurrentUserService currentUserService, IUserService userService, IDateTime dateTimeService, ICacheService cacheService = null)
     {
         _context = context;
         _currentUserService = currentUserService;
         _userService = userService;
         _dateTimeService = dateTimeService;
+        _cacheService = cacheService;
     }
 
     public async Task<int> Handle(ClaimSocialMediaAchievementForUserCommand request, CancellationToken cancellationToken)
@@ -41,8 +43,8 @@ public async Task<int> Handle(ClaimSocialMediaAchievementForUserCommand request,
             //                  in a strange bug. Switching to use the user and
             //                  achievement entities resolved the problem. See:
             //                  https://github.com/SSWConsulting/SSW.Rewards.API/issues/20
-            var user = await _context.Users.FindAsync(currentUserId);
-            var achievement = await _context.Achievements.FindAsync(achievementId);
+            var user = await _context.Users.FindAsync(currentUserId, cancellationToken);
+            var achievement = await _context.Achievements.FindAsync(achievementId, cancellationToken);
 
             userAchievement = new UserAchievement
             {
@@ -53,6 +55,8 @@ public async Task<int> Handle(ClaimSocialMediaAchievementForUserCommand request,
             };
             _context.UserAchievements.Add(userAchievement);
             await _context.SaveChangesAsync(cancellationToken);
+
+            _cacheService.Remove(CacheTags.UpdatedRanking);
         }
 
         return userAchievement.Id;

src/Application/Achievements/Command/PostAchievement/PostAchievementCommand.cs

@@ -1,6 +1,5 @@
-using SSW.Rewards.Shared.DTOs.Achievements;
-using SSW.Rewards.Application.Achievements.Queries.Common;
-using SSW.Rewards.Application.System.Commands.Common;
+using SSW.Rewards.Application.System.Commands.Common;
+using SSW.Rewards.Shared.DTOs.Achievements;
 
 namespace SSW.Rewards.Application.Achievements.Command.PostAchievement;
 
@@ -13,22 +12,25 @@ public class PostAchievementCommandHandler : IRequestHandler<PostAchievementComm
 {
     private readonly IUserService _userService;
     private readonly IApplicationDbContext _context;
+    private readonly ICacheService _cacheService;
     private readonly IMapper _mapper;
 
     public PostAchievementCommandHandler(
         IUserService UserService,
         IApplicationDbContext context,
+        ICacheService cacheService,
         IMapper mapper)
     {
         _userService = UserService;
         _context = context;
+        _cacheService = cacheService;
         _mapper = mapper;
     }
 
     public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request, CancellationToken cancellationToken)
     {
-        var requestedAchievement = await _context
-           .Achievements
+        var requestedAchievement = await _context.Achievements
+           .TagWithContext("GetRelevantAchievement")
            .Where(a => a.Code == request.Code)
            .FirstOrDefaultAsync(cancellationToken);
 
@@ -39,45 +41,51 @@ public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request,
                 status = ClaimAchievementStatus.NotFound
             };
         }
-        
+
         var achievementModel = _mapper.Map<AchievementDto>(requestedAchievement);
 
         var userId = await _userService.GetCurrentUserId(cancellationToken);
 
-        var userAchievements = await _context
-            .UserAchievements
+        var userAchievements = await _context.UserAchievements
+            .TagWithContext("GetAllUserAchievement")
+            .Include(x => x.Achievement)
             .Where(ua => ua.UserId == userId)
             .ToListAsync(cancellationToken);
-        
+
         // check for milestone achievements
         if (requestedAchievement.Type == AchievementType.Scanned)
         {
             var scannedUser = await _context.Users
+                .TagWithContext("GetScannedUserByAchievementId")
                 .FirstOrDefaultAsync(u => u.AchievementId == requestedAchievement.Id, cancellationToken);
-            
+
             if (scannedUser == null)
             {
                 var staffMember = await _context.StaffMembers
+                    .TagWithContext("GetScannedStaffMember")
                     .Include(s => s.StaffAchievement)
                     .Where(s => s.StaffAchievement != null)
                     .FirstOrDefaultAsync(s => s.StaffAchievement!.Id == requestedAchievement.Id, cancellationToken);
 
                 if (staffMember != null)
                 {
                     var staffUser = await _context.Users
+                        .TagWithContext("GetScannedUserByEmail")
                         .FirstOrDefaultAsync(u => u.Email == staffMember.Email, cancellationToken);
-                    
+
                     achievementModel.UserId = staffUser?.Id;
                 }
             }
             else
             {
                 achievementModel.UserId = scannedUser.Id;
             }
-            
+
             if (!userAchievements.Any(ua => ua.Achievement.Name == MilestoneAchievements.MeetSSW))
             {
-                var meetAchievement = await _context.Achievements.FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.MeetSSW, cancellationToken);
+                var meetAchievement = await _context.Achievements
+                    .TagWithContext("GetMilestone-MeetSSW")
+                    .FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.MeetSSW, cancellationToken);
 
                 var userMeetAchievement = new UserAchievement
                 {
@@ -117,7 +125,9 @@ public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request,
 
                     if (!userAchievements.Any(ua => ua.Achievement.Name == MilestoneAchievements.AttendUG))
                     {
-                        var ugAchievement = await _context.Achievements.FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendUG, cancellationToken);
+                        var ugAchievement = await _context.Achievements
+                            .TagWithContext("GetMilestone-AttendUG")
+                            .FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendUG, cancellationToken);
                         milestoneAchievement.Achievement = ugAchievement;
                     }
                     break;
@@ -126,7 +136,9 @@ public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request,
 
                     if (!userAchievements.Any(ua => ua.Achievement.Name == MilestoneAchievements.AttendHackday))
                     {
-                        var hdAchievement = await _context.Achievements.FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendHackday, cancellationToken);
+                        var hdAchievement = await _context.Achievements
+                            .TagWithContext("GetMilestone-AttendHackDay")
+                            .FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendHackday, cancellationToken);
                         milestoneAchievement.Achievement = hdAchievement;
                     }
                     break;
@@ -135,7 +147,9 @@ public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request,
 
                     if (!userAchievements.Any(ua => ua.Achievement.Name == MilestoneAchievements.AttendSuperpowers))
                     {
-                        var spAchievement = await _context.Achievements.FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendSuperpowers, cancellationToken);
+                        var spAchievement = await _context.Achievements
+                            .TagWithContext("GetMilestone-AttendSuperpowers")
+                            .FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendSuperpowers, cancellationToken);
                         milestoneAchievement.Achievement = spAchievement;
                     }
                     break;
@@ -144,7 +158,9 @@ public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request,
 
                     if (!userAchievements.Any(ua => ua.Achievement.Name == MilestoneAchievements.AttendWorkshop))
                     {
-                        var wsAchievement = await _context.Achievements.FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendWorkshop, cancellationToken);
+                        var wsAchievement = await _context.Achievements
+                            .TagWithContext("GetMilestone-AttendWorkshop")
+                            .FirstOrDefaultAsync(a => a.Name == MilestoneAchievements.AttendWorkshop, cancellationToken);
                         milestoneAchievement.Achievement = wsAchievement;
                     }
                     break;
@@ -161,6 +177,8 @@ public async Task<ClaimAchievementResult> Handle(PostAchievementCommand request,
 
         await _context.SaveChangesAsync(cancellationToken);
 
+        _cacheService.Remove(CacheTags.UpdatedRanking);
+
         return new ClaimAchievementResult
         {
             viewModel = achievementModel,

src/Application/Achievements/Command/UpdateAchievement/UpdateAchievementCommand.cs

@@ -13,10 +13,12 @@ public class UpdateAchievementCommand : IRequest<Unit>
 public sealed class UpdateAchievementCommandHandler : IRequestHandler<UpdateAchievementCommand, Unit>
 {
     private readonly IApplicationDbContext _context;
+    private readonly ICacheService _cacheService;
 
-    public UpdateAchievementCommandHandler(IApplicationDbContext context)
+    public UpdateAchievementCommandHandler(IApplicationDbContext context, ICacheService cacheService)
     {
         _context = context;
+        _cacheService = cacheService;
     }
 
     public async Task<Unit> Handle(UpdateAchievementCommand request, CancellationToken cancellationToken)
@@ -34,6 +36,9 @@ public async Task<Unit> Handle(UpdateAchievementCommand request, CancellationTok
         achievement.IsMultiscanEnabled = request.IsMultiscanEnabled;
 
         await _context.SaveChangesAsync(cancellationToken);
+
+        _cacheService.Remove(CacheTags.UpdatedRanking);
+
         return Unit.Value;
     }
 }

src/Application/Common/Constants/CacheKeys.cs

@@ -0,0 +1,24 @@
+namespace SSW.Rewards.Application.Common.Constants;
+
+public static class CacheKeys
+{
+    public const string Leaderboard = "LeaderboardAllTime";
+    public const string UserRanking = "UserRankingsAllTime";
+}
+
+/// <summary>
+/// Used to manage and remove multiple caches relative to their usage.
+/// For instance, claiming an achievement impacts leaderboard and rankings while claiming a reward impacts only leaderboard (due to AdminUI).
+/// 
+/// As number of cache keys grows, this helps developer to organise cache keys by impact so they can be removed all at once for certain use case.
+/// </summary>
+public static class CacheTags
+{
+    public static readonly string[] UpdatedOnlyRewards = [CacheKeys.Leaderboard];
+    public static readonly string[] Rankings = [CacheKeys.UserRanking];
+
+    public static readonly string[] UpdatedRanking = [.. UpdatedOnlyRewards, .. Rankings];
+    public static readonly string[] NewlyUserCreated = [.. UpdatedRanking];
+
+    public static readonly string[] AllStatic = [.. UpdatedRanking];
+}

src/Application/Common/Interfaces/ICacheService.cs

@@ -0,0 +1,9 @@
+
+namespace SSW.Rewards.Application.Common.Interfaces;
+
+public interface ICacheService
+{
+    Task<TItem> GetOrAddAsync<TItem>(string cacheKey, Func<Task<TItem>> factory);
+    void Remove(string cacheKey);
+    void Remove(params string[] cacheKeys);
+}

src/Application/Common/Options/CacheOptions.cs

@@ -0,0 +1,8 @@
+namespace SSW.Rewards.Application.Common.Options;
+
+public class CacheOptions
+{
+    public bool Enabled { get; set; }
+    public TimeSpan DefaultExpiration { get; set; }
+    public Dictionary<string, TimeSpan> OverrideExpiration { get; set; } = new();
+}

src/Application/GlobalUsings.cs

@@ -2,6 +2,7 @@
 global using FluentValidation;
 global using MediatR;
 global using Microsoft.EntityFrameworkCore;
+global using SSW.Rewards.Application.Common.Constants;
 global using SSW.Rewards.Application.Common.Extensions;
 global using SSW.Rewards.Application.Common.Interfaces;
 global using SSW.Rewards.Domain.Entities;