초기커밋

2025-05-01 07:20:41 +09:00
commit 98bb2e3c5c
2747 changed files with 646947 additions and 0 deletions
--- a/UGQDataAccess/Repository/Query/AccountQuery.cs
+++ b/UGQDataAccess/Repository/Query/AccountQuery.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using MongoDB.Bson;
+using MongoDB.Driver;
+using UGQDataAccess.Repository.Models;
+using UGQDatabase.Models;
+using static UGQDataAccess.Repository.Query.QuestContentQuery;
+
+namespace UGQDataAccess.Repository.Query;
+
+public static class AccountQuery
+{
+
+    public class AllAccountQueryJoin : AccountEntity
+    {
+        public IEnumerable<QuestContentEntity> QuestContents { get; set; } = null!;
+        public int QuestCount { get; set; } = 0;
+    }
+
+
+    public static Expression<Func<AllAccountQueryJoin, AccountItemResult>> AccountItemResultProjection =
+        x => new AccountItemResult
+        {
+            UserGuid = x.UserGuid,
+            Nickname = x.Nickname,
+            AccountId = x.AccountId ?? "",
+            AdditionalSlotCount = x.AdditionalSlotCount,
+            GradeType = x.GradeType,
+            CreatorPoint = x.CreatorPoint,
+            CreatedAt = x.CreatedAt,
+            QuestCount = x.QuestCount,
+        };
+
+    public static PipelineDefinition<AccountEntity, T> allAccountPipeline<T>(
+        FilterDefinition<AccountEntity> filter,
+        Expression<Func<AllAccountQueryJoin, T>> projection)
+    {
+        var lookupStage1 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestContent" },
+                { "localField", "UserGuid" },
+                { "foreignField", "UserGuid" },
+                { "pipeline",
+                    new BsonArray
+                    {
+                        new BsonDocument("$match",
+                        new BsonDocument("IsDeleted", false))
+                    } },
+                { "as", "QuestContents" }
+            });
+
+        var addFields1 = new BsonDocument("$addFields",
+            new BsonDocument("QuestCount",
+                new BsonDocument("$size", "$QuestContents")));
+
+        var pipeline = new EmptyPipelineDefinition<AccountEntity>()
+            .Match(filter)
+            .AppendStage<AccountEntity, AccountEntity, AllAccountQueryJoin>(lookupStage1)
+            .AppendStage<AccountEntity, AllAccountQueryJoin, AllAccountQueryJoin>(addFields1)
+            .Project(projection);
+
+        return pipeline;
+    }
+
+}
+
--- a/UGQDataAccess/Repository/Query/QuestContentQuery.cs
+++ b/UGQDataAccess/Repository/Query/QuestContentQuery.cs
@@ -0,0 +1,563 @@
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using MongoDB.Driver;
+using UGQDataAccess.Repository.Models;
+using UGQDatabase.Models;
+
+namespace UGQDataAccess.Repository.Query;
+
+public static class QuestContentQuery
+{
+    public class QuestBoardQueryJoin : QuestContentEntity
+    {
+        public IEnumerable<LikeEntity> Likes { get; set; } = null!;
+        public int LikeCount { get; set; } = 0;
+        public IEnumerable<BookmarkEntity> Bookmarks { get; set; } = null!;
+        public int BookmarkCount { get; set; } = 0;
+
+        public List<QuestAcceptedEntity> QuestAccepteds { get; set; } = null!;
+        public int QuestAcceptedCount { get; set; } = 0;
+
+        public List<QuestAcceptedEntity> QuestCompleteds { get; set; } = null!;
+        public int QuestCompletedCount { get; set; } = 0;
+    }
+
+    public class QuestSummariesQueryJoin : QuestContentEntity
+    {
+        public IEnumerable<LikeEntity> Likes { get; set; } = null!;
+        public int LikeCount { get; set; } = 0;
+        public IEnumerable<BookmarkEntity> Bookmarks { get; set; } = null!;
+        public int BookmarkCount { get; set; } = 0;
+
+        public List<QuestAcceptedEntity> QuestAccepteds { get; set; } = null!;
+        public int QuestAcceptedCount { get; set; } = 0;
+
+        public List<QuestAcceptedEntity> QuestCompleteds { get; set; } = null!;
+        public int QuestCompletedCount { get; set; } = 0;
+
+        public List<QuestAcceptedEntity> QuestAborteds { get; set; } = null!;
+        public int QuestAbortedCount { get; set; } = 0;
+
+        public List<ReportEntity> Reports { get; set; } = null!;
+        public int ReporCount { get; set; } = 0;
+
+        public List<CreatorPointHistoryEntity> ProfitHistories { get; set; } = null!;
+        public double TotalProfit { get; set; } = 0;
+    }
+
+    public class QuestProfitStatsQueryJoin : QuestContentEntity
+    {
+        public List<QuestAcceptedEntity> QuestCompleteds { get; set; } = null!;
+        public int QuestCompletedCount { get; set; } = 0;
+
+        public List<CreatorPointHistoryEntity> ProfitHistories { get; set; } = null!;
+        public double TotalProfit { get; set; } = 0;
+    }
+
+    public class QuestAcceptedLookup : QuestAcceptedEntity
+    {
+    }
+
+    public static Expression<Func<QuestBoardQueryJoin, QuestBoardItemResult>> QuestBoardItemResultProjection =
+            x => new QuestBoardItemResult
+            {
+                QuestId = x.QuestId,
+                Revision = x.Revision,
+                Author = x.Author,
+                Title = x.Title,
+                Languages = x.Langs,
+                Cost = x.Cost,
+                GradeType = x.GradeType,
+                TitleImagePath = x.TitleImagePath,
+                BannerImagePath = x.BannerImagePath,
+                UpdatedAt = x.UpdatedAt,
+                LikeCount = x.LikeCount,
+                BookmarkCount = x.BookmarkCount,
+            };
+    
+
+    public static Expression<Func<QuestSummariesQueryJoin, SummaryItemResult>> SummaryItemResultProjection =
+        x => new SummaryItemResult
+        {
+            QuestContentId = x.Id.ToString(),
+            QuestId = x.QuestId,
+            Revision = x.Revision,
+            BeaconId = x.BeaconId,
+
+            UserGuid = x.UserGuid,
+            Author = x.Author,
+
+            UgcBeaconGuid = x.UgcBeaconGuid,
+            UgcBeaconNickname = x.UgcBeaconNickname,
+
+            GradeType = x.GradeType,
+
+            Title = x.Title,
+            Languages = x.Langs,
+            Description = x.Description,
+            Cost = x.Cost,
+            TitleImagePath = x.TitleImagePath,
+            BannerImagePath = x.BannerImagePath,
+            State = x.State,
+            UpdatedAt = x.UpdatedAt,
+            CreatedAt = x.CreatedAt,
+
+            AcceptedCount = x.QuestAcceptedCount,
+            CompletedCount = x.QuestCompletedCount,
+            LikeCount = x.LikeCount,
+            BookmarkCount = x.BookmarkCount,
+            ReportCount = x.ReporCount,
+
+            TotalProfit = x.TotalProfit,
+            Savelanguage = x.Savelanguage,
+        };
+
+    public static Expression<Func<QuestProfitStatsQueryJoin, QuestProfitStatsItemResult>> QuestProfitStatsResultProjection =
+        x => new QuestProfitStatsItemResult
+        {
+            QuestContentId = x.Id.ToString(),
+            QuestId = x.QuestId,
+            Revision = x.Revision,
+
+            Title = x.Title,
+            Languages = x.Langs,
+            TitleImagePath = x.TitleImagePath,
+            BannerImagePath = x.BannerImagePath,
+
+            CompletedCount = x.QuestCompletedCount,
+            TotalProfit = x.TotalProfit,
+        };
+
+
+    static List<UgqGradeType> getGradeTypes(UgqUICategoryGradeType gradeType)
+    {
+        switch (gradeType)
+        {
+            case UgqUICategoryGradeType.Amateur:
+                return [UgqGradeType.Amature];
+            case UgqUICategoryGradeType.RisingStar:
+                return [UgqGradeType.RisingStar];
+            case UgqUICategoryGradeType.Master:
+                return [UgqGradeType.Master1, UgqGradeType.Master2, UgqGradeType.Master3];
+        }
+
+        return [];
+    }
+
+    static async Task<List<long>> getBookmarks(IMongoCollection<BookmarkEntity> bookmarkCollection, string userGuid)
+    {
+        var filterBuilder = Builders<BookmarkEntity>.Filter;
+        var filter = filterBuilder.Eq(x => x.UserGuid, userGuid);
+
+        var list = await bookmarkCollection.Find(filter).ToListAsync();
+
+        return list.Select(x => x.QuestId).ToList();
+    }
+
+    static async Task<List<int>> searchNpcs(IMongoCollection<NpcNameEntity> npcNameCollection, string searchText)
+    {
+        var filterBuilder = Builders<NpcNameEntity>.Filter;
+        var filter = filterBuilder.Empty;
+
+        if (string.IsNullOrEmpty(searchText) == false)
+        {
+            filter &= (filterBuilder.Regex(x => x.NpcName.Kr, searchText) |
+                filterBuilder.Regex(x => x.NpcName.En, searchText) |
+                filterBuilder.Regex(x => x.NpcName.Jp, searchText));
+        }
+
+        var list = await npcNameCollection.Find(filter).ToListAsync();
+
+        return list.Select(x => x.NpcId).ToList();
+    }
+
+    static FilterDefinition<QuestContentEntity> searchTitle(FilterDefinitionBuilder<QuestContentEntity> filterBuilder, string searchText)
+    {
+        return filterBuilder.Regex(x => x.Title.Kr, searchText) |
+            filterBuilder.Regex(x => x.Title.En, searchText) |
+            filterBuilder.Regex(x => x.Title.Jp, searchText);
+    }
+
+    public static async Task<FilterDefinition<QuestContentEntity>> summariesFilter(string? userGuid,
+       UgqSearchType searchType, string? searchText, QuestContentState state,
+       IMongoCollection<AccountEntity> accountCollection,
+       IMongoCollection<NpcNameEntity> npcNameCollection)
+    {
+        var filterBuilder = Builders<QuestContentEntity>.Filter;
+        var filter = filterBuilder.Eq(x => x.IsDeleted, false);
+
+        if (state != QuestContentState.None)
+        {
+            if(state == QuestContentState.Uncomplate ||
+                state == QuestContentState.Editable)
+            {
+                var UncomplateOrFilter = filterBuilder.Eq(x => x.State, QuestContentState.Uncomplate);
+                var EditableOrFilter = filterBuilder.Eq(x => x.State, QuestContentState.Editable);
+                filter &= filterBuilder.Or(UncomplateOrFilter, EditableOrFilter);
+            }
+            else
+            {
+                filter &= filterBuilder.Eq(x => x.State, state);
+            }
+        }
+
+        if (string.IsNullOrEmpty(userGuid) == false)
+            filter &= filterBuilder.Eq(x => x.UserGuid, userGuid);
+
+        if (string.IsNullOrEmpty(searchText) == false)
+        {
+            switch (searchType)
+            {
+                case UgqSearchType.Title:
+                    filter &= searchTitle(filterBuilder, searchText);
+                    break;
+                case UgqSearchType.Beacon:
+                    var npcIds = await searchNpcs(npcNameCollection, searchText);
+                    filter &= (filterBuilder.In(x => x.BeaconId, npcIds) |
+                        filterBuilder.Regex(x => x.UgcBeaconNickname, searchText));
+
+                    break;
+            }
+        }
+
+        return filter;
+    }
+
+    public static async Task<FilterDefinition<QuestContentEntity>> questBoardFilter(string? userGuid,
+        UgqUICategoryGradeType gradeType, UgqSearchType searchType, string? searchText,
+        IMongoCollection<AccountEntity> accountCollection,
+        IMongoCollection<NpcNameEntity> npcNameCollection)
+    {
+        var filterBuilder = Builders<QuestContentEntity>.Filter;
+        var filter = filterBuilder.Eq(x => x.IsDeleted, false);
+
+        filter &= filterBuilder.Eq(x => x.State, QuestContentState.Live);
+
+        if (string.IsNullOrEmpty(userGuid) == false)
+            filter &= filterBuilder.Eq(x => x.UserGuid, userGuid);
+
+        if(gradeType != UgqUICategoryGradeType.None)
+        {
+            var gradeTypes = getGradeTypes(gradeType);
+            filter &= filterBuilder.In(x => x.GradeType, gradeTypes);
+        }
+
+        if (string.IsNullOrEmpty(searchText) == false)
+        {
+            switch (searchType)
+            {
+                case UgqSearchType.Title:
+                    filter &= searchTitle(filterBuilder, searchText);
+                    break;
+                case UgqSearchType.Beacon:
+                    var npcIds = await searchNpcs(npcNameCollection, searchText);
+                    filter &= (filterBuilder.In(x => x.BeaconId, npcIds) |
+                        filterBuilder.Regex(x => x.UgcBeaconNickname, searchText));
+                    break;
+            }
+        }
+
+        return filter;
+    }
+
+    public static async Task<FilterDefinition<QuestContentEntity>> questBoardBookmarkFilter(string userGuid,
+        UgqUICategoryGradeType gradeType, UgqSearchType searchType, string? searchText,
+        IMongoCollection<NpcNameEntity> npcNameCollection,
+        IMongoCollection<BookmarkEntity> bookmarkCollection)
+    {
+        var filterBuilder = Builders<QuestContentEntity>.Filter;
+        var filter = filterBuilder.Eq(x => x.IsDeleted, false);
+
+        filter &= filterBuilder.Eq(x => x.State, QuestContentState.Live);
+
+        if (gradeType != UgqUICategoryGradeType.None)
+        {
+            var gradeTypes = getGradeTypes(gradeType);
+            filter &= filterBuilder.In(x => x.GradeType, gradeTypes);
+        }
+
+        var bookmarkQuestIds = await getBookmarks(bookmarkCollection, userGuid);
+        filter &= filterBuilder.In(x => x.QuestId, bookmarkQuestIds);
+
+        if (string.IsNullOrEmpty(searchText) == false)
+        {
+            switch (searchType)
+            {
+                case UgqSearchType.Title:
+                    filter &= searchTitle(filterBuilder, searchText);
+                    break;
+                case UgqSearchType.Beacon:
+                    var npcIds = await searchNpcs(npcNameCollection, searchText);
+                    filter &= (filterBuilder.In(x => x.BeaconId, npcIds) |
+                        filterBuilder.Regex(x => x.UgcBeaconNickname, searchText));
+                    break;
+            }
+        }
+
+        return filter;
+    }
+
+    public static SortDefinition<T> questBoardSort<T>(UgqSortType sortType)
+    {
+        var sortBuilder = Builders<T>.Sort;
+        SortDefinition<T> sort;
+        switch (sortType)
+        {
+            case UgqSortType.New:
+                sort = Builders<T>.Sort.Descending("UpdatedAt");
+                break;
+            case UgqSortType.Like:
+                sort = Builders<T>.Sort.Descending("LikeCount");
+                break;
+            case UgqSortType.Bookmark:
+                sort = Builders<T>.Sort.Descending("BookmarkCount");
+                break;
+            default:
+                sort = Builders<T>.Sort.Descending("UpdatedAt");
+                break;
+        }
+
+        return sort;
+    }
+
+    public static PipelineDefinition<QuestContentEntity, T> summariesPipeline<T>(
+        IMongoCollection<LikeEntity> likeCollection,
+        IMongoCollection<BookmarkEntity> bookmarkCollection,
+        FilterDefinition<QuestContentEntity> filter,
+        Expression<Func<QuestSummariesQueryJoin, T>> projection)
+    {
+        var lookupStage1 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestAccepted" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "pipeline",
+                    new BsonArray
+                    {
+                        new BsonDocument("$match",
+                        new BsonDocument("Reason", "Player"))
+                    } },
+                { "as", "QuestAccepteds" }
+            });
+
+        var addFields1 = new BsonDocument("$addFields",
+            new BsonDocument("QuestAcceptedCount",
+                new BsonDocument("$size", "$QuestAccepteds")));
+
+        var lookupStage2 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestCompleted" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "as", "QuestCompleteds" }
+            });
+
+        var addFields2 = new BsonDocument("$addFields",
+            new BsonDocument("QuestCompletedCount",
+                new BsonDocument("$size", "$QuestCompleteds")));
+
+        var lookupStage3 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestAborted" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "as", "QuestAborteds" }
+            });
+
+        var addFields3 = new BsonDocument("$addFields",
+            new BsonDocument("QuestAbortedCount",
+                new BsonDocument("$size", "$QuestAborteds")));
+
+        var lookupStage4 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "CreatorPointHistory" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "pipeline",
+                    new BsonArray
+                    {
+                        new BsonDocument("$match",
+                        new BsonDocument("Kind", "QuestProfit"))
+                    } },
+                { "as", "ProfitHistories" }
+            });
+
+        var addFields4 = new BsonDocument("$addFields",
+            new BsonDocument("TotalProfit",
+                new BsonDocument("$sum", "$ProfitHistories.Amount")));
+
+
+        var lookupStage5 = new BsonDocument("$lookup",
+           new BsonDocument
+           {
+                { "from", "Report" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "as", "Reports" }
+           });
+
+        var addFields5 = new BsonDocument("$addFields",
+            new BsonDocument("ReporCount",
+                new BsonDocument("$size", "$Reports")));
+
+        var pipeline = new EmptyPipelineDefinition<QuestContentEntity>()
+            .Match(filter)
+            .Lookup<QuestContentEntity, QuestContentEntity, LikeEntity, QuestSummariesQueryJoin>(
+                likeCollection,
+                x => x.QuestId,
+                x => x.QuestId,
+                x => x.Likes)
+            .Lookup<QuestContentEntity, QuestSummariesQueryJoin, BookmarkEntity, QuestSummariesQueryJoin>(
+                bookmarkCollection,
+                x => x.QuestId,
+                x => x.QuestId,
+                x => x.Bookmarks)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>("{$addFields: {LikeCount: {$size:'$Likes'}}}")
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>("{$addFields: {BookmarkCount: {$size:'$Bookmarks'}}}")
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(lookupStage1)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(addFields1)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(lookupStage2)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(addFields2)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(lookupStage3)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(addFields3)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(lookupStage4)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(addFields4)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(lookupStage5)
+            .AppendStage<QuestContentEntity, QuestSummariesQueryJoin, QuestSummariesQueryJoin>(addFields5)
+
+            .Project(projection);
+
+        return pipeline;
+    }
+
+    public static PipelineDefinition<QuestContentEntity, T> questProfitStatsPipeline<T>(
+        FilterDefinition<QuestContentEntity> filter,
+        Expression<Func<QuestProfitStatsQueryJoin, T>> projection)
+    {
+        var lookupStage1 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestCompleted" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "as", "QuestCompleteds" }
+            });
+
+        var addFields1 = new BsonDocument("$addFields",
+            new BsonDocument("QuestCompletedCount",
+                new BsonDocument("$size", "$QuestCompleteds")));
+
+        var lookupStage2 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "CreatorPointHistory" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "pipeline",
+                    new BsonArray
+                    {
+                        new BsonDocument("$match",
+                        new BsonDocument("Kind", "QuestProfit"))
+                    } },
+                { "as", "ProfitHistories" }
+            });
+
+        var addFields2 = new BsonDocument("$addFields",
+            new BsonDocument("TotalProfit",
+                new BsonDocument("$sum", "$ProfitHistories.Amount")));
+
+        var pipeline = new EmptyPipelineDefinition<QuestContentEntity>()
+            .Match(filter)
+            .AppendStage<QuestContentEntity, QuestContentEntity, QuestProfitStatsQueryJoin>(lookupStage1)
+            .AppendStage<QuestContentEntity, QuestProfitStatsQueryJoin, QuestProfitStatsQueryJoin>(addFields1)
+            .AppendStage<QuestContentEntity, QuestProfitStatsQueryJoin, QuestProfitStatsQueryJoin>(lookupStage2)
+            .AppendStage<QuestContentEntity, QuestProfitStatsQueryJoin, QuestProfitStatsQueryJoin>(addFields2)
+
+            .Project(projection);
+
+        return pipeline;
+    }
+
+    public static PipelineDefinition<QuestContentEntity, T> questBoardPipeline<T>(
+        IMongoCollection<LikeEntity> likeCollection,
+        IMongoCollection<BookmarkEntity> bookmarkCollection,
+        FilterDefinition<QuestContentEntity> filter,
+        Expression<Func<QuestBoardQueryJoin, T>> projection)
+    {
+        var pipeline = new EmptyPipelineDefinition<QuestContentEntity>()
+            .Match(filter)
+            .Lookup<QuestContentEntity, QuestContentEntity, LikeEntity, QuestBoardQueryJoin>(
+                likeCollection,
+                x => x.QuestId,
+                x => x.QuestId,
+                x => x.Likes)
+            .Lookup<QuestContentEntity, QuestBoardQueryJoin, BookmarkEntity, QuestBoardQueryJoin>(
+                bookmarkCollection,
+                x => x.QuestId,
+                x => x.QuestId,
+                x => x.Bookmarks)
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>("{$addFields: {LikeCount: {$size:'$Likes'}}}")
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>("{$addFields: {BookmarkCount: {$size:'$Bookmarks'}}}")
+            .Project(projection);
+
+        return pipeline;
+    }
+
+    public static PipelineDefinition<QuestContentEntity, T> questBoardDetailPipeline<T>(
+        IMongoCollection<LikeEntity> likeCollection,
+        IMongoCollection<BookmarkEntity> bookmarkCollection,
+        FilterDefinition<QuestContentEntity> filter,
+        Expression<Func<QuestBoardQueryJoin, T>> projection)
+    {
+        var lookupStage1 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestAccepted" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "pipeline",
+                    new BsonArray
+                    {
+                        new BsonDocument("$match",
+                        new BsonDocument("Reason", "Player"))
+                    } },
+                { "as", "QuestAccepteds" }
+            });
+
+        var lookupStage2 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "QuestCompleted" },
+                { "localField", "QuestId" },
+                { "foreignField", "QuestId" },
+                { "as", "QuestCompleteds" }
+            });
+
+        var pipeline = new EmptyPipelineDefinition<QuestContentEntity>()
+            .Match(filter)
+            .Lookup<QuestContentEntity, QuestContentEntity, LikeEntity, QuestBoardQueryJoin>(
+                likeCollection,
+                x => x.QuestId,
+                x => x.QuestId,
+                x => x.Likes)
+            .Lookup<QuestContentEntity, QuestBoardQueryJoin, BookmarkEntity, QuestBoardQueryJoin>(
+                bookmarkCollection,
+                x => x.QuestId,
+                x => x.QuestId,
+                x => x.Bookmarks)
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>(lookupStage1)
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>(lookupStage2)
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>("{$addFields: {LikeCount: {$size:'$Likes'}}}")
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>("{$addFields: {BookmarkCount: {$size:'$Bookmarks'}}}")
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>("{$addFields: {QuestAcceptedCount: {$size:'$QuestAccepteds'}}}")
+            .AppendStage<QuestContentEntity, QuestBoardQueryJoin, QuestBoardQueryJoin>("{$addFields: {QuestCompletedCount: {$size:'$QuestCompleteds'}}}")
+            .Project(projection);
+
+        return pipeline;
+    }
+}
+
--- a/UGQDataAccess/Repository/Query/ReserveAccountGradeQuery.cs
+++ b/UGQDataAccess/Repository/Query/ReserveAccountGradeQuery.cs
@@ -0,0 +1,51 @@
+using MongoDB.Bson;
+using MongoDB.Driver;
+using System.Linq.Expressions;
+using UGQDataAccess.Repository.Models;
+using UGQDatabase.Models;
+
+
+public static class ReserveAccountGradeQuery
+{
+
+    public class AllReserveAccountGradeQueryJoin : ReserveAccountGradeEntity
+    {
+        public IEnumerable<AccountEntity> Accounts { get; set; } = null!;
+    }
+
+
+    public static Expression<Func<AllReserveAccountGradeQueryJoin, ReserveAccountGradeItemResult>> ReserveAccountGradeItemResultProjection =
+        x => new ReserveAccountGradeItemResult
+        {
+            ReserveId = x.Id.ToString(),
+            UserGuid = x.UserGuid,
+            CurrentGradeType = x.BeforeGradeType,
+            AccountId = x.Accounts.First().AccountId ?? string.Empty,
+            ReserveGradeType = x.ReserveGradeType,
+            ReserveTime = x.ReserveTime,
+            UpdatedAt = x.UpdatedAt,
+            IsCompleted = x.IsCompleted,
+        };
+
+    public static PipelineDefinition<ReserveAccountGradeEntity, T> allReserveAccountGradePipeline<T>(
+        FilterDefinition<ReserveAccountGradeEntity> filter,
+        Expression<Func<AllReserveAccountGradeQueryJoin, T>> projection)
+    {
+        var lookupStage1 = new BsonDocument("$lookup",
+            new BsonDocument
+            {
+                { "from", "Account" },
+                { "localField", "UserGuid" },
+                { "foreignField", "UserGuid" },
+                { "as", "Accounts" }
+            });
+
+        var pipeline = new EmptyPipelineDefinition<ReserveAccountGradeEntity>()
+            .Match(filter)
+            .AppendStage<ReserveAccountGradeEntity, ReserveAccountGradeEntity, AllReserveAccountGradeQueryJoin>(lookupStage1)
+            .Project(projection);
+
+        return pipeline;
+    }
+
+}