Expedience/Expedience.Infrastructure/ExpedienceRepository.cs

using System;
using System.Collections.Generic;
using EFCore.NamingConventions.Internal;
using Enyim.Caching;
using Expedience.Infrasctructure.Models;
using Expedience.Infrastructure.Models;
using Expedience.Models;
using Microsoft.EntityFrameworkCore;

namespace Expedience.Infrastructure;

public interface IExpedienceRepository
{
	ValueTask<List<DutyCompletionRecord>> GetDutyCompletionRecords(string expac, CancellationToken cancellationToken);
    ValueTask<List<DeepDungeonRecord>> GetDeepDungeonRecords(CancellationToken cancellationToken);
    ValueTask<List<TopXCompletionResultDto>> GetTopXRecords(int recordType, int territoryId, int limit, CancellationToken cancellationToken);
}

public class ExpedienceRepository : IExpedienceRepository
{
    private readonly ExpedienceContext _dbContext;
    private readonly IMemcachedClient _memcachedClient;

    public ExpedienceRepository(ExpedienceContext dbContext, IMemcachedClient memcachedClient)
    {
        _dbContext = dbContext;
        _memcachedClient = memcachedClient;
    }

    public async ValueTask<List<DutyCompletionRecord>> GetDutyCompletionRecords(string expac, CancellationToken cancellationToken)
    {
        var cacheKey = $"xpd-dcr-{expac}";
        var cacheSeconds = 600;
        var records = await _memcachedClient.GetValueOrCreateAsync(cacheKey, cacheSeconds,
            async () => await _dbContext.DutyCompletionRecords.FromSqlInterpolated($"SELECT * FROM public.get_dutycompletionrecords({expac})")
                .ToListAsync(cancellationToken));

        return records;
    }

    public async ValueTask<List<DeepDungeonRecord>> GetDeepDungeonRecords(CancellationToken cancellationToken)
    {
        var cacheKey = $"xpd-dd";
        var cacheSeconds = 600;
        var records = await _memcachedClient.GetValueOrCreateAsync(cacheKey, cacheSeconds,
            async () => await _dbContext.DeepDungeonRecords.FromSqlInterpolated($"SELECT * FROM public.get_deepdungeonresults()")
                .ToListAsync(cancellationToken));

        return records;
    }

    public async ValueTask<List<TopXCompletionResultDto>> GetTopXRecords(int recordType, int territoryId, int limit, CancellationToken cancellationToken)
    {
        var cacheKey = $"xpd-topx-{recordType}-{territoryId}-{limit}";

        var cacheSeconds = 600;
        var records = await _memcachedClient.GetValueOrCreateAsync(cacheKey, cacheSeconds,
            async () =>
            {
                var topXResults = await _dbContext.TopXRecords.FromSqlInterpolated($"SELECT * FROM public.get_topxcompletionresults({recordType}, {territoryId}, {limit})")
                    .ToListAsync(cancellationToken);

                if (topXResults.Count == 0) return new List<TopXCompletionResultDto>();

                var uploadId = topXResults.First().Id;
                var userIds = topXResults.Select(r => r.UserId).Distinct().ToList();

                var dutyCompletionResult = await _dbContext.DutyCompletionResults
                    .FirstAsync(dcr => dcr.Id == uploadId);

                var dcrDto = new DutyCompletionResultDto
                {
                    Id = uploadId,
                    UserId = dutyCompletionResult.UserId,
                    TerritoryId = dutyCompletionResult.TerritoryId,
                    HasEcho = dutyCompletionResult.HasEcho,
                    IsUnrestricted = dutyCompletionResult.IsUnrestricted,
                    IsMinILevel = dutyCompletionResult.IsMinILevel,
                    HasNpcMembers = dutyCompletionResult.HasNpcMembers,
                    StartTime = dutyCompletionResult.StartTime,
                    EndTime = dutyCompletionResult.EndTime,
                    Hours = dutyCompletionResult.Hours,
                    Minutes = dutyCompletionResult.Minutes,
                    Seconds = dutyCompletionResult.Seconds,
                    Milliseconds = dutyCompletionResult.Milliseconds,
                    GameVersion = dutyCompletionResult.GameVersion,
                    PluginVersion = dutyCompletionResult.PluginVersion,
                    Lang = dutyCompletionResult.Lang,
                    DataCenter = dutyCompletionResult.DataCenter,
                    UploadedAt = dutyCompletionResult.UploadedAt
                };
                var dutyMembers = await _dbContext.DutyMembers
                    .Where(dm => dm.UploadId == uploadId)
                    .ToListAsync();

                var users = await _dbContext.Users
                    .Where(u => userIds.Contains(u.UserId))
                    .ToListAsync();

                var territory = await _dbContext.Territories
                    .FirstAsync(t => t.TerritoryId == territoryId);

                var territoryDto = new TerritoryDto
                {
                    TerritoryId = territory.TerritoryId,
                    PlaceName = territory.PlaceName,
                    ContentName = territory.ContentName,
                    Level = territory.Level,
                    ContentType = territory.ContentType,
                    Expac = territory.Expac
                };

                
                var resultDtos = topXResults.Select(result => new TopXCompletionResultDto
                {
                    Rank = result.Rank,
                    Duration = result.Duration,
                    DutyCompletionResult = dcrDto,
                    DutyMembers = dutyMembers
                        .Where(dm => dm.UploadId == result.Id)
                        .Select(dm => new DutyMemberDto
                        {
                            UploadId = dm.UploadId,
                            GroupNumber = dm.GroupNumber,
                            MemberNumber = dm.MemberNumber,
                            Level = dm.Level,
                            ClassJob = dm.ClassJob,
                            IsNpc = dm.IsNpc
                        }).ToList(),
                    Territory = territoryDto
,
                    User = users
                        .Where(u => u.UserId == result.UserId)
                        .Select(u => new UserDto
                        {
                            UserId = u.UserId,
                            UserName = u.UserName,
                            WorldId = u.WorldId
                        }).FirstOrDefault()
                }).ToList();


                return resultDtos;
            });

       return records;
    }
}