초기커밋

GameServer/Contents/Quest/Action/EndQuestAction.cs

@@ -0,0 +1,192 @@
+using Amazon.S3.Model;
+using Google.Protobuf.WellKnownTypes;
+using Newtonsoft.Json;
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class EndQuestAction : EntityActionBase
+    {
+        private ConcurrentDictionary<(UInt32, UInt32/*questid, revision*/), ServerCommon.EndQuest> m_end_quests = new();
+
+
+        public EndQuestAction(EntityBase owner)
+            : base(owner)
+        {
+        }
+
+        public override async Task<Result> onInit()
+        {
+            await Task.CompletedTask;
+
+            var result = new Result();
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            m_end_quests.Clear();
+        }
+
+        public async Task<Result> loadEndQuests()
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None
+                                                              , server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQEndQuestsReadAll(owner.getUserGuid()));
+            }
+            var result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+
+            return result;
+        }
+
+        public void addEndQuest(ServerCommon.EndQuest endQuest)
+        {
+            if (endQuest is null)
+            {
+                Log.getLogger().error("endQuest is null !!!");
+                return;
+            }
+            var end_quest_attribute = endQuest.getEntityAttribute<EndQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(end_quest_attribute, () => $"end_quest_attribute is null !!!");
+
+            _ = m_end_quests.TryAdd((end_quest_attribute.QuestId, end_quest_attribute.QuestRevision), endQuest);
+
+            //if (false == m_end_quests.TryAdd((end_quest_attribute.QuestId, end_quest_attribute.QuestRevision), endQuest))
+            //{
+            //    Log.getLogger().error($"endQuest TryAdd fail  !!! quest : {JsonConvert.SerializeObject(endQuest)}");
+            //    return;
+            //}
+        }
+
+        public Result setEndQuestsFromDoc(EndQuestDoc doc)
+        {
+            var result = new Result();
+            
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var end_quest_attrib = doc.getAttrib<EndQuestAttrib>();
+            NullReferenceCheckHelper.throwIfNull(end_quest_attrib, () => $"end_quest_attrib is null !!!");
+
+            ServerCommon.EndQuest end_quest = new ServerCommon.EndQuest(owner, owner.getUserGuid(), end_quest_attrib.m_quest_id, end_quest_attrib.m_quest_revision);
+
+            var attribute = end_quest.getEntityAttribute<EndQuestAttribute>();
+            if (attribute is null)
+            {
+                var err_msg = $"Fail to get QuestAttribute";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+
+            if (false == doc.getAttribWrappers().TryGetValue(typeof(EndQuestAttrib), out var to_copy_doc_attrib))
+            {
+                var err_msg = $"Fail to get QuestAttrib";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+
+            var attrib_base = to_copy_doc_attrib.getAttribBase();
+            var doc_attrib = attrib_base as EndQuestAttrib;
+            if (doc_attrib is null)
+            {
+                var err_msg = $"Fail to get QuestAttrib";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+
+            attribute.QuestId = doc_attrib.m_quest_id;
+            attribute.EndCount = doc_attrib.m_end_count;
+            attribute.LastEndTime = doc_attrib.m_last_end_time;
+
+            if (false == m_end_quests.TryAdd((attribute.QuestId, attribute.QuestRevision), end_quest))
+            {
+                var err_msg = $"m_end_quest try Add Fail";
+                result.setFail(ServerErrorCode.ServerLogicError, err_msg);
+                return result;
+            }
+
+            return result;
+        }
+
+        public ConcurrentDictionary<(UInt32, UInt32), ServerCommon.EndQuest> getEndQuests()
+        {
+            return m_end_quests;
+        }
+
+        public ServerCommon.EndQuest? getEndQuest(UInt32 questId, UInt32 questRevision)
+        {
+            if (m_end_quests.TryGetValue((questId, questRevision), out var end_quest))
+            {
+                return end_quest;
+            }
+            return null;
+        }
+
+        public Result endQuestCheck(MetaAssets.EQuestType questType, UInt32 questId, UInt32 questRevision)
+        {
+            var result = new Result();
+            
+            //normal은 체크안한다.
+            if (questType == MetaAssets.EQuestType.NORMAL) return result;
+            
+            if (true == m_end_quests.ContainsKey((questId, questRevision)))
+            {
+                result.setFail(ServerErrorCode.QuestAlreadyEnded, $"Quest Already End. QuestID : {questId}");
+                return result;
+            }
+
+            return result;
+        }
+
+        public bool hasEndQuest(UInt32 questId, UInt32 questRevision = 0)
+        {
+            return m_end_quests.ContainsKey((questId, questRevision));
+        }
+
+        public List<QuestEndInfo> makeQuestEndInfo(List<(UInt32, UInt32)> questIdAndRevisions)
+        {
+
+            var infos = new List<QuestEndInfo>();
+            foreach (var quest_id_revision in questIdAndRevisions)
+            {
+                if (false == m_end_quests.TryGetValue(quest_id_revision, out var end_quest))
+                {
+                    Log.getLogger().error($"makeQuestEndInfo End Quest Not Found. QuestID : {quest_id_revision}");
+                    continue;
+                }
+
+                var end_quest_attribute = end_quest.getEntityAttribute<EndQuestAttribute>();
+                NullReferenceCheckHelper.throwIfNull(end_quest_attribute, () => $"end_quest_attribute is null !!!");
+
+                var quest_id = quest_id_revision.Item1;
+                var quest_revision = quest_id_revision.Item2;
+                var ugq_quest_id = QuestHelper.convertQuestIdAndRevisionToUgqQuestId(quest_id, quest_revision);
+                
+                var info = new QuestEndInfo();
+                info.ComposedQuestId = ugq_quest_id;
+                info.EndCount = end_quest_attribute.EndCount;
+                info.LastEndTime = Timestamp.FromDateTime(end_quest_attribute.LastEndTime);
+
+                infos.Add(info);
+            }
+
+            return infos;
+        
+        }
+    }
+}

GameServer/Contents/Quest/Action/QuestAbandonAction.cs

@@ -0,0 +1,60 @@
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class QuestAbandonAction : EntityActionBase
+    {
+        public QuestAbandonAction(EntityBase owner)
+            : base(owner)
+        {
+        }
+
+        public override async Task<Result> onInit()
+        {
+            await Task.CompletedTask;
+
+            var result = new Result();
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public async Task<Result> abandonQuestConditionCheck(UInt32 questId)
+        {
+            var result = new Result();
+            var owner = getOwner() as Player;
+            ArgumentNullException.ThrowIfNull(owner);
+
+            var quest_action = owner.getEntityAction<QuestAction>();
+            ArgumentNullException.ThrowIfNull(quest_action);
+
+            (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+            if (result.isFail()) return result;
+            var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+            NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+            if (result.isFail()) return result;
+            var quest_type = EnumHelper.convertEnumValueStringToEnum(quest_base_info.QuestType, MetaAssets.EQuestType.NORMAL);
+            
+            result = quest_action.hasQuest(quest_type, questId);
+            if(result.isFail()) return result;
+
+            if (quest_base_info.QuestType.Equals(nameof(MetaAssets.EQuestType.TUTORIAL)))
+            {
+                result.setFail(ServerErrorCode.QuestAbandonOnlyNormal, $"Epic Quest cannot abandon Data QuestID : {questId}");
+                return result;
+            }
+            return result;
+        }
+    }
+}

GameServer/Contents/Quest/Action/QuestAcceptAction.cs

@@ -0,0 +1,327 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class AcceptQuestVariable
+{
+    public QuestBaseInfo? m_quest_base_info_nullable { get; set; } = null;
+    public bool m_is_mail_quest { get; set; } = false;
+    public ServerCommon.Quest? m_new_quest_nullable { get; set; } = null;
+    public MetaAssets.EQuestType m_quest_type { get; set; } = MetaAssets.EQuestType.NONE;
+    public Int32 m_quest_cost { get; set; } = 0;
+
+    //public CommonResult m_common_result { get; set; } = new();
+    public List<UInt32> assignable_quests { get; set; } = new();
+
+
+    public AcceptQuestVariable()
+    {
+        m_quest_base_info_nullable = null;
+        m_is_mail_quest = false;
+        m_quest_type = MetaAssets.EQuestType.NONE;
+        m_new_quest_nullable = null;
+    }
+
+    public AcceptQuestVariable(QuestBaseInfo metaInfo, bool isMailQuest, ServerCommon.Quest quest, Int32 questCost = 0)
+    {
+        m_quest_base_info_nullable = metaInfo;
+        m_is_mail_quest = isMailQuest;
+        m_new_quest_nullable = quest;
+
+        if (false == EnumHelper.tryParse(metaInfo.QuestType, out MetaAssets.EQuestType quest_type))
+        {
+            m_quest_type = MetaAssets.EQuestType.NONE;
+        }
+        else m_quest_type = quest_type;
+
+        m_quest_cost = questCost;
+    }
+
+}
+
+public class QuestAcceptAction : EntityActionBase
+{
+    public QuestAcceptAction(EntityBase owner)
+        : base(owner)
+    {}
+
+    public override async Task<Result> onInit()
+    {
+        await Task.CompletedTask;
+
+        var result = new Result();
+
+        return result;
+    }
+
+    public override void onClear()
+    {
+        return;
+    }
+
+    
+    public async Task<Result> acceptQuestConditionCheck(UInt32 questId, AcceptQuestVariable acceptQuestVar)
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var quest_action = owner.getEntityAction<QuestAction>();
+        var quest_mail_action = owner.getEntityAction<QuestMailAction>();
+        var end_quest_action = owner.getEntityAction<EndQuestAction>();
+        NullReferenceCheckHelper.throwIfNull(quest_action);
+        NullReferenceCheckHelper.throwIfNull(quest_mail_action);
+        NullReferenceCheckHelper.throwIfNull(end_quest_action);
+        
+        
+
+        //해당 퀘스트 정보 불러오기
+        (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+        if (result.isFail()) return result;
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+        acceptQuestVar.m_quest_base_info_nullable = quest_base_info;
+        NullReferenceCheckHelper.throwIfNull(acceptQuestVar.m_quest_base_info_nullable, () => $"acceptQuestVar.m_quest_base_info_nullable is null !!!");
+        if (false == EnumHelper.tryParse(acceptQuestVar.m_quest_base_info_nullable.QuestType, out MetaAssets.EQuestType quest_type))
+        {
+            result.setFail(ServerErrorCode.ServerLogicError, $"QuestType Parse Failed : {acceptQuestVar.m_quest_base_info_nullable.QuestType}");
+            return result;
+        }
+        acceptQuestVar.m_quest_type = quest_type;
+
+        //현재 보유중인 퀘스트인지 체크
+        quest_action.getQuest(quest_type, questId, out var existedQuest);
+        if (existedQuest is not null)
+        {
+            result.setFail(ServerErrorCode.QuestAlreadyExist, $"Quest Already Exist quest Type : {acceptQuestVar.m_quest_base_info_nullable.QuestType}, questId : {questId}");
+            return result;
+        }
+        
+
+        //메일로 받는 경우 메일 가지고 있는지 체크
+        acceptQuestVar.m_is_mail_quest = acceptQuestVar.m_quest_base_info_nullable.AssignType.Equals(MetaAssets.EAssignType.MAIL.ToString());
+        if (acceptQuestVar.m_is_mail_quest)
+        {
+            result = quest_mail_action.hasQuestMail(quest_type, questId, true);
+            if (result.isFail()) return result;
+        }
+
+        //이미 완료한 퀘스트 인지 체크
+        result = end_quest_action.endQuestCheck(quest_type, questId, 0);
+        if (result.isFail()) return result;
+
+
+        //내가 들고 있는 퀘스트의 전체 타입 수를 정리 하고 이미 퀘스트가 꽉차서 받을 수 없으면 에러 처리
+        result = quest_action.assignableQuestCheckByQuestType(acceptQuestVar.m_quest_type);
+        if (result.isFail()) return result;
+
+        return result;
+    }
+
+    public (Result, AcceptQuestVariable) acceptQuestByNpcDialogue(QuestBaseInfo questMetaInfo)
+    {
+        var owner = getOwner() as Player;
+        ArgumentNullException.ThrowIfNull(owner);
+
+        var new_quest = new ServerCommon.Quest(owner, owner.getUserGuid());
+        ArgumentNullException.ThrowIfNull(new_quest);
+
+        var quest_attribute = new_quest.getEntityAttribute<QuestAttribute>();
+        ArgumentNullException.ThrowIfNull(quest_attribute);
+        AcceptQuestVariable acceptQuestVar = new(questMetaInfo, false, new_quest);
+
+        var result = newQuestAssign(ref acceptQuestVar);
+        
+        if (result.isFail()) { return (result, acceptQuestVar); }
+
+        return (result, acceptQuestVar);
+    }
+
+    public async Task<(Result, AcceptQuestVariable?)> questAccept(UInt32 questId)
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner);
+
+        var quest_action = owner.getEntityAction<QuestAction>();
+        NullReferenceCheckHelper.throwIfNull(quest_action);
+
+        (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+        if (result.isFail()) return (result, null);
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+        var new_quest = new ServerCommon.Quest(owner, owner.getUserGuid());
+
+        AcceptQuestVariable acceptQuestVar = new(quest_base_info, false, new_quest);
+        result = newQuestAssign(ref acceptQuestVar);
+        if (result.isFail()) return (result, null);
+
+        return (result, acceptQuestVar);
+    }
+
+    public Result makeNewQuestAssignInfo(ref AcceptQuestVariable acceptQuestVar, Int32 cost = 0)
+    {
+        var result = new Result();
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner);
+
+        var quest_meta = acceptQuestVar.m_quest_base_info_nullable;
+        NullReferenceCheckHelper.throwIfNull(quest_meta, () => $"quest_meta is null !!!");
+        acceptQuestVar.m_new_quest_nullable = new ServerCommon.Quest(owner, owner.getUserGuid());
+
+        var quest_attribute = acceptQuestVar.m_new_quest_nullable.getEntityAttribute<QuestAttribute>();
+        ArgumentNullException.ThrowIfNull(quest_attribute);
+
+        DateTime nowDt = DateTimeHelper.Current;
+
+        quest_attribute.QuestId = quest_meta.QuestId;
+        quest_attribute.QuestType = acceptQuestVar.m_quest_type;
+        quest_attribute.UgqInfo.QuestRevision = quest_meta.QuestRevision;
+        quest_attribute.UgqInfo.QuestCost = cost;
+        quest_attribute.UgqInfo.UqgState = quest_meta.UgqState;
+        quest_attribute.QuestAssignTime = nowDt;
+        quest_attribute.CurrentTaskNum = 1;
+        quest_attribute.CurrentTaskComplete = 0;
+        quest_attribute.TaskStartTime = nowDt;
+        quest_attribute.QuestCompleteTime = nowDt;
+        quest_attribute.IsComplete = 0;
+        quest_attribute.HasTimer = 0;
+        quest_attribute.TimerCompleteTime = nowDt;
+        quest_attribute.CompletedIdxStrings = new();
+
+        if (false == quest_meta.QuestTaskGroupList.TryGetValue(quest_attribute.CurrentTaskNum, out var quest_task_info))
+        {
+            result.setFail(ServerErrorCode.QuestInvalidValue, $"questEventInfo InvalidData questId = {quest_attribute.QuestId}, info.CurrentTaskNum : {quest_attribute.CurrentTaskNum}");
+            return result;
+        }
+
+        quest_attribute.ActiveEvents.AddRange(QuestManager.It.getActiveEventStrings(quest_attribute, quest_task_info));
+
+        if (quest_task_info.HasCounter)
+        {
+            quest_attribute.HasCounter = (quest_task_info.HasCounter ? 1 : 0);
+            quest_attribute.MinCounter = quest_task_info.MinCounter;
+            quest_attribute.MaxCounter = quest_task_info.MaxCounter;
+            quest_attribute.CurrentCounter = quest_task_info.MinCounter;
+        }
+        if (quest_task_info.HasTimer)
+        {
+            quest_attribute.HasCounter = (quest_task_info.HasCounter ? 1 : 0);
+            quest_attribute.TimerCompleteTime = nowDt.AddSeconds(quest_task_info.RemainTime);
+        }
+
+        if (quest_task_info.HasAssignableQuest)
+        { 
+            acceptQuestVar.assignable_quests.AddRange(quest_task_info.AssignableQuestIds);
+
+        }
+        quest_attribute.newEntityAttribute();
+        return result;
+
+    }
+
+
+    public async Task<Result> reAssignQuest(UInt32 questId, UInt32 questRevision)
+    {
+        (var result, var quest) = await questAcceptWithTransaction(questId, questRevision, 0);
+        return result;
+    }
+
+
+    public async Task<(Result, ServerCommon.Quest?)> questAcceptWithTransaction(UInt32 questId, UInt32 questRevision, int recursiveCount)
+    {
+        var result = new Result();
+        if (recursiveCount > 10)
+        {
+            var err_msg = $"recursiveCount > 10 !!! : {recursiveCount}";
+            Log.getLogger().error(err_msg);
+            result.setFail(ServerErrorCode.ServerLogicError, err_msg);
+            return (result, null);
+        }
+        recursiveCount += 1;
+
+        var player = getOwner() as Player;
+        ArgumentNullException.ThrowIfNull(player);
+
+        var quest_action = player.getEntityAction<QuestAction>();
+        ArgumentNullException.ThrowIfNull(quest_action);
+
+        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(player, questId, questRevision);
+        if (result.isFail()) return (result, null);
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+        
+        var server_logic = GameServerApp.getServerLogic();
+        NullReferenceCheckHelper.throwIfNull(server_logic);
+        var new_quest = new ServerCommon.Quest(player, player.getUserGuid());
+        NullReferenceCheckHelper.throwIfNull(new_quest);
+        AcceptQuestVariable acceptQuestVar = new(quest_base_info, false, new_quest);
+
+        var fn_quest_accept = async delegate ()
+        {
+            var result = new Result();
+            result = newQuestAssign(ref acceptQuestVar);
+            if (result.isFail()) return result; 
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.None, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+            }
+
+            batch.appendBusinessLog(new QuestAcceptBusinessLog(questId, questRevision, acceptQuestVar.m_quest_type));
+
+            result = await QueryHelper.sendQueryAndBusinessLog(batch);
+            if (result.isFail()) return result;
+
+            return result;
+        };
+
+        result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "QuestAcceptWithTran", fn_quest_accept);
+        if (result.isFail())
+        {
+            var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return (result, null);
+        }
+        NullReferenceCheckHelper.throwIfNull(acceptQuestVar.m_new_quest_nullable, () => $"acceptQuestVar.m_new_quest_nullable is null !!!");
+
+        quest_action.addNewQuest(questId, acceptQuestVar.m_new_quest_nullable);
+        await player.send_GS2C_NTF_QUEST_UPDATE(questId, questRevision, new(), true);
+        await QuestManager.It.QuestCheck(player, new QuestMail(EQuestEventTargetType.QUEST, EQuestEventNameType.ACTIVED, ""));
+
+        var quest_mail_action = player.getEntityAction<QuestMailAction>();
+        ArgumentNullException.ThrowIfNull(quest_mail_action);
+        quest_mail_action.GS2C_NTF_DELETE_QUEST_MAIL_NOTI(questId);
+
+
+        foreach(var additional_quest_id in acceptQuestVar.assignable_quests)
+        {
+            await questAcceptWithTransaction(additional_quest_id, 0, recursiveCount);
+        }
+
+        return (result, new_quest);
+        
+    }
+
+
+    public Result newQuestAssign(ref AcceptQuestVariable acceptQuestVar)
+    {
+        var owner = getOwner() as Player;
+        ArgumentNullException.ThrowIfNull(owner);
+        //퀘스트 객체 데이터 채우기
+        var result = makeNewQuestAssignInfo(ref acceptQuestVar);
+        if (result.isFail()) return result;
+
+        return result;
+    }
+
+
+    
+}

GameServer/Contents/Quest/Action/QuestAction.cs

@@ -0,0 +1,948 @@
+using Newtonsoft.Json;
+using System.Collections.Concurrent;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class QuestAction : EntityActionBase
+{
+    private ConcurrentDictionary<(EQuestType, UInt32), ServerCommon.Quest> m_quests = new();
+
+    public QuestAction(EntityBase owner)
+        : base(owner)
+    { }
+
+    public override async Task<Result> onInit()
+    {
+        await Task.CompletedTask;
+
+        var result = new Result();
+
+        return result;
+    }
+
+    public override void onClear()
+    {
+        m_quests.Clear();
+        return;
+    }
+
+
+    public void removeQuest(ServerCommon.Quest quest)
+    {
+        if (quest is null)
+        {
+            Log.getLogger().error("quest is null !!!");
+            return;
+        }
+        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+
+        var quest_id = quest_attribute.QuestId;
+        var quest_type = quest_attribute.QuestType;
+
+        if (false == m_quests.TryRemove((quest_type, quest_id), out _))
+        {
+            Log.getLogger().error($"quest TryRemove fail  !!! quest : {JsonConvert.SerializeObject(quest)}");
+        }
+    }
+
+
+    public Result hasQuest(EQuestType questType, UInt32 questId, UInt32 questRevision = 0)
+    {
+        var result = new Result();
+
+        if (false == m_quests.ContainsKey((questType, questId)))
+        {
+            result.setFail(ServerErrorCode.QuestAbadonNotExistQuest, $"Quest Not Exist QuestID : {questId}, questRevision : {questRevision}");
+            return result;
+        }
+        return result;
+    }
+    public Result hasQuest(string questType, UInt32 questId, UInt32 questRevision = 0)
+    {
+        var result = new Result();
+        if (false == checkHasQuest(questType, questId))
+        {
+            result.setFail(ServerErrorCode.QuestAbadonNotExistQuest, $"Quest Not Exist QuestID : {questId}, questRevision : {questRevision}");
+            return result;
+        }
+        return result;
+    }
+
+
+    public bool checkHasQuest(EQuestType questType, UInt32 questId)
+    {
+        return m_quests.ContainsKey((questType, questId));
+    }
+
+    public bool checkHasQuest(string questType, UInt32 questId)
+    {
+        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(questType, EQuestType.NORMAL);
+        return m_quests.ContainsKey((quest_type, questId));
+    }
+
+
+    public Result deleteQuest(EQuestType questType, UInt32 questId)
+    {
+        var result = new Result();
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        if (false == m_quests.TryRemove((questType, questId), out var quest))
+        {
+            var err_msg = $"Quest Not Exist QuestID : {questId}, owner : {owner.toBasicString()}";
+            result.setFail(ServerErrorCode.QuestAbadonNotExistQuest, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        return result;
+    }
+
+    //public void deleteQuestFromdDictionary(Int32 questId, Int32 questRevision = 0)
+    //{
+    //    var quest_key = QuestMetaHelper.makeQuestsDictionaryKey(questId, questRevision);
+    //    m_quests.TryRemove(quest_key, out var _);
+    //}
+
+    public async Task<Result> setQuestsFromDoc(QuestDoc doc)
+    {
+        var result = new Result();
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        ServerCommon.Quest quest = new ServerCommon.Quest(owner, owner.getUserGuid());
+
+        var attribute = quest.getEntityAttribute<QuestAttribute>();
+
+        if (attribute is null)
+        {
+            var err_msg = $"Fail to get QuestAttribute";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+
+        if (false == doc.getAttribWrappers().TryGetValue(typeof(QuestAttrib), out var to_copy_doc_attrib))
+        {
+            var err_msg = $"Fail to get QuestAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+
+        var attrib_base = to_copy_doc_attrib.getAttribBase();
+        var doc_attrib = attrib_base as QuestAttrib;
+        if (doc_attrib is null)
+        {
+            var err_msg = $"Fail to get QuestAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+
+        attribute.QuestId = doc_attrib.m_quest_id;
+        attribute.QuestType = doc_attrib.m_quest_type;
+        attribute.UgqInfo.QuestRevision = doc_attrib.m_ugq_quest_info.QuestRevision;
+        attribute.UgqInfo.QuestCost = doc_attrib.m_ugq_quest_info.QuestCost;
+        attribute.UgqInfo.UqgState = doc_attrib.m_ugq_quest_info.UqgState;
+        attribute.QuestAssignTime = doc_attrib.m_quest_assign_time;
+        attribute.CurrentTaskNum = doc_attrib.m_current_task_num;
+        attribute.TaskStartTime = doc_attrib.m_task_start_time;
+        attribute.QuestCompleteTime = doc_attrib.m_quest_complete_time;
+        attribute.ActiveEvents = doc_attrib.m_active_events;
+        attribute.HasCounter = doc_attrib.m_has_counter;
+        attribute.MinCounter = doc_attrib.m_min_counter;
+        attribute.MaxCounter = doc_attrib.m_max_counter;
+        attribute.CurrentCounter = doc_attrib.m_current_counter;
+        attribute.IsComplete = doc_attrib.m_is_complete;
+        attribute.ReplacedRewardGroupId = doc_attrib.m_replaced_reward_group_id;
+        attribute.HasTimer = doc_attrib.m_has_timer;
+        attribute.TimerCompleteTime = doc_attrib.m_timer_complete_time;
+        attribute.CurrentTaskComplete = doc_attrib.m_is_current_task_complete;
+        attribute.CompletedIdxStrings = doc_attrib.m_completed_idx_strings;
+        attribute.m_quest_doc_nullable = doc;
+
+        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(owner, doc_attrib.m_quest_id, doc_attrib.m_ugq_quest_info.QuestRevision, attribute.UgqInfo.UqgState);
+        if(result.isFail())
+        {
+            if (attribute.UgqInfo.UqgState == UgqStateType.Test)
+            {
+                var ugq_test_action = owner.getEntityAction<UgqTestAction>();
+                var copy_doc = await attribute.toDocBase();
+                
+                _ = await ugq_test_action.ugqTestDelete(attribute);
+            }
+            else
+            {
+                var err_msg = $"getQuestMeta result fail, owner : {owner.toBasicString()}, quest_id : {doc_attrib.m_quest_id}, questRevision : {doc_attrib.m_ugq_quest_info.QuestRevision}, " +
+                $"state : {attribute.UgqInfo.UqgState}, result : {result.toBasicString()}";
+                Log.getLogger().error(err_msg);
+            }
+            return result;
+        }
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!! - {owner.toBasicString()}");
+        if (false == EnumHelper.tryParse(quest_base_info.QuestType, out MetaAssets.EQuestType quest_type))
+        {
+            attribute.QuestType = MetaAssets.EQuestType.NONE;
+        }
+        else attribute.QuestType = quest_type;
+
+
+        if (false == m_quests.TryAdd((attribute.QuestType, attribute.QuestId), quest))
+        {
+            var err_msg = $"m_quest try Add Fail type : {attribute.QuestType}, quest Id : {attribute.QuestId}, questRevision : {attribute.UgqInfo.QuestRevision}, state : {attribute.UgqInfo.UqgState}";
+            result.setFail(ServerErrorCode.ServerLogicError, err_msg);
+            return result;
+        }
+
+
+        return result;
+    }
+
+
+
+    public Result assignableQuestCheckByQuestType(EQuestType questType)
+    {
+        var result = new Result();
+
+        bool is_max = false;
+
+        Int32 epic_quest_count = 0;
+        Int32 tutorial_quest_count = 0;
+        Int32 normal_quest_count = 0;
+        Int32 ugq_quest_count = 0;
+        foreach (var quest in m_quests)
+        {
+            var quest_type = quest.Key.Item1;
+            if (quest_type.Equals(EQuestType.EPIC)) epic_quest_count++;
+            else if (quest_type.Equals(EQuestType.TUTORIAL)) tutorial_quest_count++;
+            else if (quest_type.Equals(EQuestType.NORMAL)) normal_quest_count++;
+            else if (quest_type.Equals(EQuestType.UGQ)) ugq_quest_count++;
+        }
+
+        switch (questType)
+        {
+            case MetaAssets.EQuestType.NORMAL:
+                if (normal_quest_count >= MetaHelper.GameConfigMeta.MaxNormalQuest) is_max = true;
+                break;
+            case MetaAssets.EQuestType.EPIC:
+                if (epic_quest_count >= MetaHelper.GameConfigMeta.MaxEpicQuest) is_max = true;
+                break;
+            case MetaAssets.EQuestType.TUTORIAL:
+                if (tutorial_quest_count >= MetaHelper.GameConfigMeta.MaxTutorialQuest) is_max = true;
+                break;
+            case MetaAssets.EQuestType.UGQ:
+                if (tutorial_quest_count >= MetaHelper.GameConfigMeta.MaxUGQuest) is_max = true;
+                break;
+            default:
+                break;
+        }
+
+        if (is_max)
+        {
+            result.setFail(ServerErrorCode.QuestTypeAssignCountMax, $"Quest is Max questType : {questType.ToString()}");
+            return result;
+        }
+
+
+        return result;
+
+
+
+    }
+
+
+
+    //         private List<QuestMetaInfo> makeQuestMetaInfoData(List<UserQuestInfo> infos)
+    //         {
+    //             List<QuestMetaInfo> metaInfos = new List<QuestMetaInfo>();
+    //             foreach (UserQuestInfo info in infos)
+    //             {
+    //                 if (!MetaData.Instance._QuestScriptMetaTable.TryGetValue(info.m_quest_id, out var questScripts))
+    //                 {
+    //                     Log.getLogger().error($"QuestMetaInfoData Not Exist questId : {info.m_quest_id}");
+    //                     continue;
+    //                 }
+    // 
+    //                 foreach (var script in questScripts.Values)
+    //                 {
+    //                     var meta = QuestNotifyHelper.fillQuestMetaInfo(script);
+    //                     metaInfos.Add(meta);
+    //                 }
+    //             }
+    // 
+    //             return metaInfos;
+    //         }
+
+
+
+    
+
+    public Result getQuest(string questType, UInt32 questId, out ServerCommon.Quest? quest)
+    {
+        var result = new Result();
+
+        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(questType, EQuestType.NORMAL);
+        if (false == m_quests.TryGetValue((quest_type, questId), out quest))
+        {
+            result.setFail(ServerErrorCode.QuestAssingDataNotExist, $"Quest Not Exist QuestID : {questId}");
+            return result;
+        }
+        
+        return result;
+    }
+
+    public Result getQuest(EQuestType questType, UInt32 questId, out ServerCommon.Quest? quest)
+    {
+        var result = new Result();
+
+        if (false == m_quests.TryGetValue((questType, questId), out quest))
+        {
+            result.setFail(ServerErrorCode.QuestAssingDataNotExist, $"Quest Not Exist QuestID : {questId}");
+            return result;
+        }
+
+        return result;
+    }
+
+    public async Task<(Result, ServerCommon.Quest?)> getQuest(UInt32 questId, UInt32 questRevision)
+    {
+        var result = new Result();
+        ////(result, var quest_base_info) = QuestMetaHelper.getQuestMetaInfo(questId, questRevision);
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(player, questId, questRevision);
+        if (result.isFail()) return (result, null!);
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);
+        if (false == m_quests.TryGetValue((quest_type, questId), out var quest))
+        {
+            result.setFail(ServerErrorCode.QuestAssingDataNotExist, $"Quest Not Exist QuestID : {questId}");
+            return (result, null);
+        }
+        return (result, quest);
+    }
+
+
+    public ConcurrentDictionary<(EQuestType, UInt32), ServerCommon.Quest> getQuests()
+    {
+        return m_quests;
+    }
+
+
+    public List<ServerCommon.Quest> getUgqQuests()
+    {
+        List<ServerCommon.Quest> ugq_quests = new List<ServerCommon.Quest>();
+        foreach (var quest in m_quests)
+        {
+            var quest_type = quest.Key.Item1;
+            var quest_id = quest.Key.Item2;
+            var quest_attribute = quest.Value.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+
+            if (quest_attribute.UgqInfo.QuestRevision > 0)
+            {
+                ugq_quests.Add(quest.Value);
+            }
+        }
+
+        return ugq_quests;
+    }
+
+    public List<ServerCommon.Quest> getSystemQuests()
+    {
+        List < ServerCommon.Quest > system_quests = new List<ServerCommon.Quest>();
+        foreach (var quest in m_quests.Values)
+        {
+            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+            if (quest_attribute.UgqInfo.QuestRevision == 0)
+            {
+                system_quests.Add(quest);
+            }
+        }
+
+        return system_quests;
+    }
+
+    public List<UInt32> getSystemQuestIds()
+    {
+        List<UInt32> quest_ids = new ();
+        foreach (var quest in m_quests)
+        {
+            var quest_attribute = quest.Value.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+            if (quest_attribute.UgqInfo.QuestRevision == 0)
+            {
+                quest_ids.Add(quest.Key.Item2);
+            }
+        }
+
+        return quest_ids;
+    }
+
+
+    public async Task<Result> questForceAcceptWithTransaction(UInt32 questId)
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        var server_logic = GameServerApp.getServerLogic();
+
+        AcceptQuestVariable? accept_quest_var = null;
+        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
+        var fn_quest_force_accept = async delegate ()
+        {
+            var fn_result = new Result();
+
+            (fn_result, accept_quest_var) = await quest_accept_action.questAccept(questId);
+            if (fn_result.isFail()) return fn_result;
+
+            NullReferenceCheckHelper.throwIfNull(accept_quest_var, () => $"accept_quest_var is null !!!");
+
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.QuestMainAssignForce, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+            }
+
+            batch.appendBusinessLog(new QuestAcceptBusinessLog(questId, 0, accept_quest_var.m_quest_type));
+
+            fn_result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+            return fn_result;
+        };
+
+        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "QuestForceAccept", fn_quest_force_accept);
+        if (result.isFail())
+        {
+            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return result;
+        }
+
+        if (null != accept_quest_var)
+        {
+            var quest = accept_quest_var.m_new_quest_nullable;
+
+            NullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");
+            NullReferenceCheckHelper.throwIfNull(accept_quest_var.m_quest_base_info_nullable, () => $"accept_quest_var.m_quest_base_info_nullable is null !!!");
+
+            var quest_id = accept_quest_var.m_quest_base_info_nullable.QuestId;
+            var quest_action = player.getEntityAction<QuestAction>();
+            quest_action.addNewQuest(quest_id, quest);
+            await player.send_GS2C_NTF_QUEST_UPDATE(quest_id, 0, new(), true);
+
+            foreach (var assignable_quest_id in accept_quest_var.assignable_quests)
+            {
+                await quest_accept_action.questAcceptWithTransaction(assignable_quest_id, 0, 0);
+            }
+        }
+
+        return result;
+    }
+
+
+    public async Task<List<ServerCommon.Quest>> makeNewQuestByCreateUser(List<UInt32> forceAcceptQuestIds)
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner);
+        var quest_accept_action = owner.getEntityAction<QuestAcceptAction>();
+
+        List<ServerCommon.Quest> new_quests = new List<ServerCommon.Quest>();
+
+        foreach (var questId in forceAcceptQuestIds)
+        {
+            (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+            if (result.isFail()) continue;
+            var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+            AcceptQuestVariable accept_quest_var = new();
+            accept_quest_var.m_is_mail_quest = false;
+            accept_quest_var.m_quest_base_info_nullable = quest_base_info;
+
+            result = quest_accept_action.makeNewQuestAssignInfo(ref accept_quest_var);
+            if (result.isFail()) continue;
+
+            var new_quest = accept_quest_var.m_new_quest_nullable;
+            NullReferenceCheckHelper.throwIfNull(new_quest, () => $"new_quest is null !!! - {owner.toBasicString()}");
+            new_quests.Add(new_quest);
+        }
+
+        return new_quests;
+
+    }
+
+    public async Task cheatResetAllQuests()
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "ResetAllQuests", delegateDeleteAllQuests);
+        if (result.isFail())
+        {
+            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return;
+        }
+        async Task<Result> delegateDeleteAllQuests() => await deleteAllQuests();
+
+        onClear();
+        var end_quest_action = player.getEntityAction<EndQuestAction>();
+        end_quest_action.onClear();
+
+        player.send_GS2C_NTF_QUEST_UPDATE_EMPTY();
+
+        var quest_mail_action = player.getEntityAction<QuestMailAction>();
+        (var mail_quest_ids, var force_accept_quest_ids) = await quest_mail_action.makeQuestMailDocByType(EAssignRequireType.PlayerInitial);
+
+
+        result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CheatAccecptQuests", delegateCheatAcceptQuests);
+        if (result.isFail())
+        {
+            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return;
+        }
+        async Task<Result> delegateCheatAcceptQuests() => await cheatAcceptQuests(force_accept_quest_ids);
+
+        foreach (var quest_id in force_accept_quest_ids)
+        {
+            await player.send_GS2C_NTF_QUEST_UPDATE(quest_id, 0, new(), true);
+        }
+
+        player.send_GS2C_NTF_END_QUESTS();
+
+
+
+    }
+
+    private async Task<Result> cheatAcceptQuests(List<UInt32> force_accept_quest_ids)
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
+
+        List<AcceptQuestVariable> accept_quest_vars = new List<AcceptQuestVariable>();
+        List<ILogInvoker> invokers = new();
+        foreach (var quest_id in force_accept_quest_ids)
+        {
+            (var accept_result, var quest_accept_var) = await quest_accept_action.questAccept(quest_id);
+            if (accept_result.isFail()) continue;
+
+            NullReferenceCheckHelper.throwIfNull(quest_accept_var, () => $"quest_accept_var is null !!!");
+
+            accept_quest_vars.Add(quest_accept_var);
+            
+            var business_log = new QuestAcceptBusinessLog(quest_id, 0, quest_accept_var.m_quest_type);
+            invokers.Add(business_log);
+        }
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandQuestAccept, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+
+        batch.appendBusinessLogs(invokers);
+
+        var result = await QueryHelper.sendQueryAndBusinessLog(batch);
+        if (result.isFail()) return result;
+
+        var quest_action = player.getEntityAction<QuestAction>();
+
+        foreach (var quest_var in accept_quest_vars)
+        {
+            NullReferenceCheckHelper.throwIfNull(quest_var.m_quest_base_info_nullable, () => $"quest_var.m_quest_base_info_nullable is null !!!");
+            NullReferenceCheckHelper.throwIfNull(quest_var.m_new_quest_nullable, () => $"quest_var.m_new_quest_nullable is null !!!");
+
+            quest_action.addNewQuest(quest_var.m_quest_base_info_nullable.QuestId, quest_var.m_new_quest_nullable);
+            await player.send_GS2C_NTF_QUEST_UPDATE(quest_var.m_quest_base_info_nullable.QuestId, 0, new(), true);
+        }
+
+        return result;
+
+    }
+
+    private async Task<Result> deleteAllQuests()
+    {
+        var result = new Result();
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        foreach (var quest in m_quests.Values)
+        {
+            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+            quest_attribute.deleteEntityAttribute();
+        }
+
+        var end_quest_action = player.getEntityAction<EndQuestAction>();
+        var end_quests = end_quest_action.getEndQuests();
+
+        var log_invokers = new List<ILogInvoker>();
+
+        foreach (var end_quest in end_quests.Values)
+        {
+            var end_quest_attribute = end_quest.getEntityAttribute<EndQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(end_quest_attribute, () => $"end_quest_attribute is null !!!");
+            end_quest_attribute.deleteEntityAttribute();
+
+            log_invokers.Add(new EndQuestDeleteBusinessLog(end_quest_attribute.QuestId, end_quest_attribute.QuestRevision));
+        }
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandResetAllQuest, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        batch.appendBusinessLogs(log_invokers);
+
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+        if (result.isFail()) return result;
+
+        return result;
+    }
+
+    public async Task questComplete(UInt32 questId)
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "cheatQuestComplete", delegateCheatQuestComplete);
+        if (result.isFail())
+        {
+            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return;
+        }
+        async Task<Result> delegateCheatQuestComplete() => await cheatQuestComplete(questId);
+
+        await player.send_GS2C_NTF_QUEST_UPDATE(questId, 0, new(), false);
+
+        await QuestManager.It.QuestCheck(player, new QuestActiveQuest(EQuestEventTargetType.QUEST, EQuestEventNameType.COMPLETED, questId));
+    }
+
+    private async Task<Result> cheatQuestComplete(UInt32 questId)
+    {
+        var result = new Result();
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+        if (result.isFail()) return result;
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+        result = getQuest(quest_base_info.QuestType, questId, out var quest);
+        if(result.isFail()) return result;
+
+        NullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");
+
+        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+
+        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+
+        quest_attribute.IsComplete = 1;
+        quest_attribute.ActiveEvents.Clear();
+        quest_attribute.modifiedEntityAttribute();
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandQuestComplete, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        batch.appendBusinessLog(new QuestCompleteBusinessLog(questId, 0));
+
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+        return result;
+    }
+
+    public async Task cheatAcceptQuest(UInt32 questId)
+    {
+        (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+        if (result.isFail()) return;
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);
+
+        result = hasQuest(quest_base_info.QuestType, questId);
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        if (result.isSuccess())
+        {
+            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "cheatDeleteQuest", delegatecheatDeleteQuest);
+            if (result.isFail())
+            {
+                string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
+                Log.getLogger().error(err_msg);
+                return;
+            }
+            async Task<Result> delegatecheatDeleteQuest() => await cheatDeleteQuest(quest_type, questId);
+            m_quests.TryRemove((quest_type, questId), out var _);
+        }
+        
+        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
+        await quest_accept_action.questAcceptWithTransaction(questId, 0, 0);
+    }
+
+    private async Task<Result> cheatDeleteQuest(EQuestType questType, UInt32 questId, UInt32 questRevision = 0)
+    {
+        var result = new Result();
+
+        m_quests.TryGetValue((questType, questId), out var quest);
+
+        NullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");
+
+        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+
+        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+        quest_attribute.deleteEntityAttribute();
+                    
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandDeleteQuest, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        batch.appendBusinessLog(new QuestDeleteBusinessLog(questId, questRevision));
+
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+
+        return result;
+    }
+
+
+    public async Task<Result> questAssignableItemConditionCheck(ItemMetaData itemMeta)
+    {
+        var result = new Result();
+
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        var quest_mail_action = player.getEntityAction<QuestMailAction>();
+        
+        var normal_mails = await quest_mail_action.getNormalMailSet();
+        var normal_mail_count = normal_mails.Count;
+        var quest_id = (UInt32)itemMeta.Register_id;
+
+        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
+        if (result.isFail()) return result;
+        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+        //진행중인 퀘스트가 있어서 아이템 사용 불가
+        if (true == checkHasQuest(quest_base_info.QuestType, quest_id))
+        {
+            var err_msg = $"Item Use : Already Has Quest quest_id : {quest_id}, player : {player.toBasicString()}";
+            result.setFail(ServerErrorCode.ItemUseAlreadyHasQuest, err_msg);
+            Log.getLogger().warn(err_msg);
+            return result;
+        }
+        return result;
+    }
+
+    public async Task<(Result, HashSet<UInt32>)> resetQuestCoolTimeConditionCheck()
+    {
+        var result = new Result();
+
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        var quest_mail_action = player.getEntityAction<QuestMailAction>();            
+
+        var my_normal_quest_mails = await quest_mail_action.getNormalMailSet();
+        var my_normal_quest_mail_count = my_normal_quest_mails.Count;
+                    
+        HashSet<UInt32> assignable_mail_set = await quest_mail_action.getAssignableMailSet();
+
+        //퀘스트메일이 가득차서 아이템 사용 불가
+        if (MetaHelper.GameConfigMeta.MaxQuestSendMail <= my_normal_quest_mail_count)
+        {
+            var err_msg = $"Item Use : Assignable QuestMail is Max, my_normal_quest_mail_count : {my_normal_quest_mail_count} normal_mails : {JsonConvert.SerializeObject(my_normal_quest_mails)}, player : {player.toBasicString()}";
+            result.setFail(ServerErrorCode.ItemUseQuestMailCountMax, err_msg);
+            Log.getLogger().warn(err_msg);
+            return (result, assignable_mail_set);
+        }
+        //할당가능한 퀘스트 메일이 없다. 
+        if (assignable_mail_set.Count < 1) 
+        {
+            var err_msg = $"Item Use : Assignable QuestMail is none, normal_mails : {JsonConvert.SerializeObject(my_normal_quest_mails)}, player : {player.toBasicString()}";
+            result.setFail(ServerErrorCode.ItemUseNotExistAssignableQuest, err_msg);
+            Log.getLogger().warn(err_msg);
+            return (result, assignable_mail_set);
+        }
+        
+        return (result, assignable_mail_set);
+
+    }
+
+    public async Task<(Result, AcceptQuestVariable?)> questAssignByItem(ItemMetaData itemMeta)
+    {
+        var result = new Result();
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var quest_id = (UInt32)itemMeta.Register_id;
+
+        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
+        
+        (result , var accept_quest_var) = await quest_accept_action.questAccept(quest_id);
+
+        return (result, accept_quest_var);
+    }
+
+    public void addNewQuest(UInt32 questId, ServerCommon.Quest quest)
+    {
+        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+
+        var key = (quest_attribute.QuestType, questId);
+        m_quests.TryAdd(key, quest);
+    }
+
+
+    public async Task cheatDeleteQuestAction(EQuestType questType, UInt32 questId, UInt32 questRevision)
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "cheatDeleteQuest", delegatecheatDeleteQuest);
+        if (result.isFail())
+        {
+            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return;
+        }
+        async Task<Result> delegatecheatDeleteQuest() => await cheatDeleteQuest(questType, questId, questRevision);
+
+        m_quests.TryRemove((questType, questId), out var _);
+    }
+
+    public Dictionary<UInt32, ServerCommon.Quest> getTestUgqs()
+    {
+        Dictionary<UInt32, ServerCommon.Quest> test_ugq_ids = new();
+        foreach (var quest in m_quests.Values)
+        {
+            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+
+            if (quest_attribute.QuestType == EQuestType.UGQ && quest_attribute.UgqInfo.UqgState == UgqStateType.Test)
+            {
+                test_ugq_ids.Add(quest_attribute.QuestId, quest);
+            }
+        }
+
+        return test_ugq_ids;
+    }
+
+    
+    public Result setQuestCheckFromDoc(DailyQuestCheckDoc doc)
+    {
+        var result = new Result();
+        
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var daily_quest_check_attribute = owner.getEntityAttribute<DailyQuestCheckAttribute>();
+        
+        if (daily_quest_check_attribute is null)
+        {
+            var err_msg = $"Fail to get daily_quest_check_attribute";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+        
+        if (false == doc.getAttribWrappers().TryGetValue(typeof(DailyQuestCheckAttrib), out var to_copy_doc_attrib))
+        {
+            var err_msg = $"Fail to get DailyQuestCheckAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+        
+        var attrib_base = to_copy_doc_attrib.getAttribBase();
+        var doc_attrib = attrib_base as DailyQuestCheckAttrib;
+        if (doc_attrib is null)
+        {
+            var err_msg = $"Fail to get RentalInstanceVisitAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+
+        foreach (var id in doc_attrib.m_daily_sended_quest)
+        {
+            daily_quest_check_attribute.m_daily_sended_quest.Add(id);
+        }
+        
+
+        daily_quest_check_attribute.m_next_refresh_time = doc_attrib.m_next_refresh_time;
+        daily_quest_check_attribute.m_daily_quest_check_doc_nullable = doc;
+
+        return result;
+    }
+
+    public Result setPeriodRepeatQuestFromDoc(QuestPeriodRepeatCheckDoc doc)
+    {
+        var result = new Result();
+        
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var period_repeat_quest_attribute = owner.getEntityAttribute<QuestPeriodRepeatCheckAttribute>();
+        
+        if (period_repeat_quest_attribute is null)
+        {
+            var err_msg = $"Fail to get period_repeat_quest_attribute";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+        
+        if (false == doc.getAttribWrappers().TryGetValue(typeof(QuestPeriodRepeatAttrib), out var to_copy_doc_attrib))
+        {
+            var err_msg = $"Fail to get QuestPeriodRepeatAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+        
+        var attrib_base = to_copy_doc_attrib.getAttribBase();
+        var doc_attrib = attrib_base as QuestPeriodRepeatAttrib;
+        if (doc_attrib is null)
+        {
+            var err_msg = $"Fail to get QuestPeriodRepeatAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+
+        foreach (var info in doc_attrib.m_period_repeat_quests)
+        {
+            QuestPeriodRepeatInfo repeat_info = new();
+            
+            //repeat_info.m_next_refresh_time = info.m_sen;
+
+            foreach (var send_quest in info.Value.m_sended_quest)
+            {
+                repeat_info.m_sended_quest.TryAdd(send_quest.Key, send_quest.Value);
+            }
+
+            if (false == period_repeat_quest_attribute.m_period_repeat_quests.TryAdd(info.Key, repeat_info))
+            {
+                Log.getLogger().warn($"m_period_repeat_quests add Fail info.key : {info.Key}, value : {JsonConvert.SerializeObject(info.Value)}");
+            }
+        }
+
+        return result;
+    }
+}

GameServer/Contents/Quest/Action/QuestCheatAction.cs

@@ -0,0 +1,38 @@
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer;
+
+public class QuestCheatAction : EntityActionBase
+{
+    public QuestCheatAction(EntityBase owner) : base(owner)
+    {
+    }
+
+    public override void onClear()
+    {
+        return;
+    }
+
+    public override Task<Result> onInit()
+    {
+        var result = new Result();
+        return Task.FromResult(result);
+    }
+
+    public async Task cheatSendQuestMail(UInt32 questId)
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+        var quest_mail_action = player.getEntityAction<QuestMailAction>();
+
+        await quest_mail_action.sendQuestMailsWithTransaction(new List<UInt32>() { questId });
+        
+    }
+
+}

GameServer/Contents/Quest/Action/QuestMailAction.cs

@@ -0,0 +1,722 @@
+using Amazon.S3.Model;
+using Google.Protobuf.WellKnownTypes;
+using MetaAssets;
+using Newtonsoft.Json;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using UGQDatabase.Models;
+
+namespace GameServer
+{
+    public class QuestMailAction : EntityActionBase
+    {
+        private ConcurrentDictionary<(EQuestType, UInt32) /*quest_type, quest_id*/, ServerCommon.QuestMail> m_quest_mails = new();
+        private bool m_is_quest_mail_loaded = false;
+
+        public QuestMailAction(EntityBase owner)
+            : base(owner)
+        {
+        }
+
+        public override async Task<Result> onInit()
+        {
+            await Task.CompletedTask;
+
+            var result = new Result();
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public Result hasQuestMail(EQuestType questType, UInt32 questId, bool needLog = false)
+        {
+            var result = new Result();
+
+            if (false == m_quest_mails.ContainsKey((questType, questId)))
+            {
+                var owner = getOwner() as Player;
+                NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+                var err_msg = $"Quest Mail Not Exist, questId : {questId}, owner : {owner.toBasicString()}"; 
+                result.setFail(ServerErrorCode.QuestMailNotExist, err_msg);
+                if (needLog)
+                {
+                    Log.getLogger().error(result.toBasicString());    
+                }
+                return result;
+            }
+            result.setSuccess();
+            return result;
+        }
+
+        public async Task<Result> loadQuestMails()
+        { 
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None
+                                                              , server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQQuestMailsReadAll(owner.getUserGuid()));
+            }
+            var result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+
+            return result;
+        }
+
+        public List<QuestMailInfo> getQuestMailsInfo()
+        {
+            return convertQuestMailsToProtoQuestMailInfo();
+
+        }
+
+        public (Result, ServerCommon.QuestMail) getQuestMail(EQuestType questType, UInt32 questId)
+        {
+            var result = new Result();
+            if (false == m_quest_mails.TryGetValue((questType, questId), out var quest_mail))
+            {
+                var err_msg = $"Quest Mail Not  Exist, questType : {questType}, questId : {questId}";
+                result.setFail(ServerErrorCode.QuestMailNotExist, err_msg);
+                Log.getLogger().error(err_msg);
+                return (result, null!);
+            }
+            return (result, quest_mail);
+        }
+
+        public List<ServerCommon.QuestMail> makeNewSystemQuestMail(List<(UInt32, EQuestType)> mailQuestIds)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            List < ServerCommon.QuestMail > quest_mails = new();
+
+            foreach (var quest_id in mailQuestIds)
+            {
+                (var quest_mail, var log_invoker) = createQuestMail(quest_id.Item1, 0, false);
+                if (quest_mail is not null) quest_mails.Add(quest_mail);
+            }
+            return quest_mails;
+        }
+
+        public async Task<(List<(UInt32, EQuestType)>, List<UInt32>)> makeQuestMailDocByType(EAssignRequireType type)
+        {
+            if (QuestManager.It._QuestReqTypeGroup.TryGetValue(type.ToString(), out var quest_ids) == false)
+            {
+                Log.getLogger().error($"SendQuestMailByType - QuestReqTypeGroup not found. type : {type}, " +
+                    $"groupInfo : {JsonConvert.SerializeObject(QuestManager.It._QuestReqTypeGroup)}");
+                return (new(), new());
+            }
+            List<(UInt32, EQuestType)> mail_quests = new();
+            List<UInt32> force_accept_quests = new();
+
+            foreach (var quest_id in quest_ids)
+            {
+                (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
+                if (result.isFail()) continue;
+                var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+                NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+                if (quest_base_info.AssignType.Equals(nameof(EAssignType.MAIL)) && quest_base_info.ForceAccept == false)
+                {
+                    var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);
+                    mail_quests.Add((quest_id, quest_type));
+                    continue;
+                }
+                else if (quest_base_info.AssignType.Equals(nameof(EAssignType.MAIL)) && quest_base_info.ForceAccept == true)
+                {
+                    force_accept_quests.Add(quest_id);
+                    continue;
+                }
+            }
+
+            return (mail_quests, force_accept_quests);            
+        }
+
+        public async Task<Result> readQuestMail(UInt32 questId, UInt32 questRevision)
+        { 
+            var result = new Result();
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var quest_type = await QuestMetaHelper.getQuestType(player, questId, questRevision);
+
+            if (false == m_quest_mails.TryGetValue((quest_type, questId), out var quest_mail))
+            {
+                var err_msg = $"Quest Mail Not  Exist, questId : {questId}";
+                Log.getLogger().error(err_msg);
+                result.setFail(ServerErrorCode.QuestMailNotExist, err_msg);
+                return result;
+            }
+
+            var quest_mail_attribute = quest_mail.getEntityAttribute<QuestMailAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_mail_attribute, () => $"quest_mail_attribute is null !!!");
+
+            quest_mail_attribute.IsRead = 1;
+            quest_mail_attribute.modifiedEntityAttribute();
+
+            return result;
+        
+        }
+
+        public async Task<QuestMailInfo?> convertQuestMailsToProtoQuestMailInfo(UInt32 questId, UInt32 questRevision)
+        {
+            QuestMailInfo info = new();
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var quest_type = await QuestMetaHelper.getQuestType(player, questId, questRevision);
+
+            if (false == m_quest_mails.TryGetValue((quest_type, questId), out var questMail))
+            {
+                Log.getLogger().error($"QuestInfo {questId} not exist, {player.toBasicString()}");
+                return null;
+            }
+
+            (var result, var quest_mail_attibute) = getQuestMailAttribFromAttribute(questMail);
+            if (result.isFail())
+            {
+                Log.getLogger().error($"QuestInfo {questId} Attrivute not exist, {player.toBasicString()}");
+                return null;
+            }
+            NullReferenceCheckHelper.throwIfNull(quest_mail_attibute, () => $"quest_mail_attibute is null !!!");
+
+            info.ComposedQuestId = QuestHelper.convertQuestIdAndRevisionToUgqQuestId(quest_mail_attibute.QuestId, quest_mail_attibute.QuestRevision);
+            info.CreateTime = Timestamp.FromDateTime(quest_mail_attibute.CreateTime);
+            info.IsRead = quest_mail_attibute.IsRead;
+
+            return info;
+        }
+
+        public List<QuestMailInfo> convertQuestMailsToProtoQuestMailInfo()
+        {
+            List<QuestMailInfo> quest_mails = new();
+
+
+            foreach (var quest_mail in m_quest_mails)
+            {
+                QuestMailInfo info = new();
+                (var result, var quest_mail_attibute) = getQuestMailAttribFromAttribute(quest_mail.Value);
+                if (result.isFail())
+                {
+                    continue;
+                }
+                NullReferenceCheckHelper.throwIfNull(quest_mail_attibute, () => $"quest_mail_attibute is null !!!");
+
+                info.ComposedQuestId = quest_mail_attibute.QuestId;
+                info.CreateTime = Timestamp.FromDateTime(quest_mail_attibute.CreateTime);
+                info.IsRead = quest_mail_attibute.IsRead;
+
+                quest_mails.Add(info);
+            }
+            return quest_mails;
+        }
+        
+
+        private (Result, QuestMailAttribute?) getQuestMailAttribFromAttribute(ServerCommon.QuestMail questMail)
+        {
+            var attribute = questMail.getEntityAttribute<QuestMailAttribute>();
+            var result = new Result();
+            if (attribute is null)
+            {
+                var err_msg = $"Fail to get QuestMailAttribute";
+                Log.getLogger().error(err_msg);
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return (result, null);
+            }
+            return (result, attribute);
+        }
+
+        public Result setEndQuestsFromDoc(QuestMailDoc doc)
+        {
+            var result = new Result();
+            var owner = getOwner();
+
+//             ServerCommon.QuestMail quest_mail = new ServerCommon.QuestMail(owner);
+// 
+//             var attribute = quest_mail.getEntityAttribute<QuestMailAttribute>();
+//             if (attribute is null)
+//             {
+//                 var err_msg = $"Fail to get QuestMailAttribute";
+//                 result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+//                 return result;
+//             }
+// 
+//             if (false == doc.getAttribWrappers().TryGetValue(typeof(QuestMailAttrib), out var to_copy_doc_attrib))
+//             {
+//                 var err_msg = $"Fail to get QuestMailAttrib";
+//                 result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+//                 return result;
+//             }
+//             var attrib_base = to_copy_doc_attrib.getAttribBase();
+//             var doc_attrib = attrib_base as QuestMailAttrib;
+//             if (doc_attrib is null)
+//             {
+//                 var err_msg = $"Fail to get FriendAttrib";
+//                 result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+//                 return result;
+//             }
+// 
+//             attribute.QuestId = doc_attrib.QuestId;
+//             attribute.CreateTime = doc_attrib.CreateTime;
+//             attribute.IsRead = doc_attrib.IsRead;
+// 
+// 
+//             if (false == m_quest_mails.TryAdd(attribute.QuestId, quest_mail))
+//             {
+//                 var err_msg = $"m_quest_mails try Add Fail";
+//                 result.setFail(ServerErrorCode.ServerLogicError, err_msg);
+//                 return result;
+//             }
+
+            return result;
+        }
+
+
+        public bool GS2C_NTF_DELETE_QUEST_MAIL_NOTI(UInt32 questId)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            ClientToGame ntf_packet = new();
+            ntf_packet.Message = new();
+            ntf_packet.Message.DeleteQuestMailNoti = new();
+            ntf_packet.Message.DeleteQuestMailNoti.QuestId = questId;
+
+            if (false == GameServerApp.getServerLogic().onSendPacket(owner, ntf_packet)) return false;
+            return true;
+
+            
+        }
+
+        public async Task<Result> normalMailActiveCheck()
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var normal_mail_set = await getNormalMailSet();
+
+            var result = new Result();
+
+            //메일이 삭제 됐으니 무조건 보낼수 있다. 단, 컨피그 데이터에서 최대 메일수를 줄여버리면 몇개 거절해도 할당 되면 안되니 여기서 리턴
+            if (MetaHelper.GameConfigMeta.MaxQuestSendMail <= normal_mail_set.Count) return result;
+
+            //메일 보낼 수 있는 퀘스트가 없으면 return;
+            var assignable_mail_set = await getAssignableMailSet();
+            if (assignable_mail_set.Count < 1) { return result; }
+
+            var repeat_quest_action = player.getEntityAction<RepeatQuestAction>();
+             
+            //이미 체크 중이면 리턴
+            if (repeat_quest_action.isChecking() == 1) return result;
+
+            var server_logic = GameServerApp.getServerLogic();
+
+            var fn_transaction_runner = async delegate ()
+            {
+                var result = new Result();
+
+                DateTime now_dt = DateTimeHelper.Current;
+                var next_allocate_dt = now_dt.AddMinutes(MetaHelper.GameConfigMeta.CooltimeNormalQuestSendMail);
+
+                repeat_quest_action.setRepeatQuestInfo(next_allocate_dt, 1);
+
+                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.QuestMainRepeatTimeRefresh, server_logic.getDynamoDbClient());
+                {
+                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+                }
+
+                var repeat_quest_attribute = player.getEntityAttribute<RepeatQuestAttribute>();
+                NullReferenceCheckHelper.throwIfNull(repeat_quest_attribute, () => $"repeat_quest_attribute is null !!!");
+
+                batch.appendBusinessLog(new RepeatQuestBusinessLog(repeat_quest_attribute.m_next_allocate_time, repeat_quest_attribute.m_is_checking));
+
+                result = await QueryHelper.sendQueryAndBusinessLog(batch);
+                return result;
+            };
+
+            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "NormalMailCheckActive", fn_transaction_runner);
+            if (result.isFail())
+            {
+                return result;
+                
+            }
+
+            QuestManager.It.m_normal_quest_check_users.TryAdd(player.getUserGuid(), 1);
+
+            return result;
+        }
+
+
+        public async Task<HashSet<UInt32>> getNormalMailSet()
+        {
+            HashSet<UInt32> normalMailSet = new();
+            foreach (var mailQuestKey in m_quest_mails.Keys)
+            {
+                (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(mailQuestKey.Item2);
+                if (result.isFail()) continue;
+                var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+                NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+                if (quest_base_info.QuestType.Equals(MetaAssets.EQuestType.NORMAL.ToString()) && quest_base_info.OncePeriodRangeType.Equals(OncePeriodRangeType.Nolimit))
+                {
+                    normalMailSet.Add(mailQuestKey.Item2);    
+                }
+            }
+
+            return normalMailSet;
+        }
+
+        public async Task<HashSet<UInt32>> getAssignableMailSet()
+        {
+            var normal_mails = await getNormalMailSet();
+
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var quest_action = owner.getEntityAction<QuestAction>();
+            var end_quest_action = owner.getEntityAction<EndQuestAction>();
+            var quest_ids = quest_action.getSystemQuestIds();
+            
+            //var my_quest_ids = quests.Keys.ToList();
+
+            var end_quests = end_quest_action.getEndQuests();
+
+            HashSet<UInt32> assignable_quest_ids = new();
+            foreach (var questGroup in QuestManager.It._QuestNormalGroup)
+            {
+                if (questGroup.Key == 0 || end_quests.ContainsKey((questGroup.Key, 0)))
+                {
+                    foreach (var quest_id in questGroup.Value.ToList())
+                    {
+                        //메일에 있으니 continue
+                        if (normal_mails.Contains(quest_id)) continue;
+                        if (quest_ids.Contains(quest_id)) continue;
+
+                        assignable_quest_ids.Add(quest_id);
+                    }
+
+                }
+            }
+            return assignable_quest_ids;
+
+        }
+
+        public async Task<(Result, List<ServerCommon.QuestMail>, List<ILogInvoker>)> sendQuestMails(List<UInt32> questIds)
+        {
+            var result = new Result();
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            List<ServerCommon.QuestMail> quest_mails = new();
+            List<ILogInvoker> log_invokers = new();
+            foreach (var quest_id in questIds)
+            {
+                (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
+                if (result.isFail()) continue;
+                
+                //여기에 Revision이 들어야가되면 0 대신 revision 값 셋팅 해야함
+                (var quest_mail, var log_invoker) = createQuestMail(quest_id, 0, true);
+                if (quest_mail is null) continue;
+
+                NullReferenceCheckHelper.throwIfNull(log_invoker, () => $"log_invoker is null !!!");
+
+                quest_mails.Add(quest_mail);
+                log_invokers.Add(log_invoker);
+            }
+
+            return (result, quest_mails, log_invokers);
+        }
+
+        public async Task<(Result, List<ServerCommon.QuestMail>)> sendQuestMailsWithTransaction(List<UInt32> questIds)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            var server_logic = GameServerApp.getServerLogic();
+
+            List<ServerCommon.QuestMail> quest_mails = new();
+            var fn_transaction_runner = async delegate ()
+            {
+                (var result, quest_mails, var log_invokers) = await sendQuestMails(questIds);
+
+                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.None, server_logic.getDynamoDbClient());
+                {
+                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+                }
+
+                batch.appendBusinessLogs(log_invokers);
+                result = await QueryHelper.sendQueryAndBusinessLog(batch);
+                if (result.isFail())
+                {
+                    return result;
+                }
+                return result;
+            };
+
+            var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "SendQuestMails", fn_transaction_runner);
+            if (result.isFail())
+            {
+                var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
+                Log.getLogger().error(err_msg);
+                return (result, new());
+            }
+
+            await addNewQuestMails(quest_mails);
+            await send_NTF_RECEIVED_QUEST_MAIL(player, questIds);
+            await QuestManager.It.QuestCheck(player, new QuestMail(EQuestEventTargetType.MAIL, EQuestEventNameType.RECEIVED, ""));
+
+
+            return (result, quest_mails);
+
+        }
+
+        public async Task send_NTF_RECEIVED_QUEST_MAIL(Player owner, List<UInt32> questIds)
+        {
+            List<QuestMailInfo> infos = new();
+            foreach (var id in questIds)
+            {
+                var quest_mail_info = await getQuestMailInfo(id);
+                if (quest_mail_info is null) continue;
+                infos.Add(quest_mail_info);
+            }
+
+            ClientToGame clientToGameNoti = new();
+            clientToGameNoti.Message = new();
+            clientToGameNoti.Message.ReceiveQuestMailNoti = new();
+            clientToGameNoti.Message.ReceiveQuestMailNoti.QuestMailInfo.AddRange(infos);
+
+            if (false == GameServerApp.getServerLogic().onSendPacket(owner, clientToGameNoti))
+            {
+                Log.getLogger().error($"NTF_RECEIVED_QUEST_MAIL send error questIds = {JsonConvert.SerializeObject(questIds)}");
+            }
+
+        }
+        private async Task<QuestMailInfo?> getQuestMailInfo(UInt32 questId)
+        {
+            //여기에 Revision이 들어야가되면 0 대신 revision 값 셋팅 해야함
+            return await convertQuestMailsToProtoQuestMailInfo(questId, 0);
+        }
+
+        public async Task<Result> deleteQuestMail(UInt32 questId, UInt32 questRevision)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            var quest_type = await QuestMetaHelper.getQuestType(player, questId, questRevision);
+            var result = new Result();
+            if (false == m_quest_mails.TryRemove((quest_type, questId), out var quest_mail))
+            { 
+                var err_msg = $"deleteQuestMail, Quest Mail Not Exist, questId : {questId}";
+                result.setFail(ServerErrorCode.QuestMailNotExist, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+
+            return result;        
+        }
+
+        private (ServerCommon.QuestMail?, ILogInvokerEx?) createQuestMail(UInt32 questId, UInt32 questRevision, bool checkPeriod)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            DateTime now_dt = DateTimeHelper.Current;
+
+            var quest_mail = new ServerCommon.QuestMail(owner);
+            //await quest_mail.onInit();
+            var attribute = quest_mail.getEntityAttribute<QuestMailAttribute>();
+            if (attribute is null)
+            {
+                return (null, null);
+            }
+            attribute.QuestId = questId;
+            attribute.CreateTime = now_dt;
+            attribute.IsRead = 0;
+            attribute.QuestRevision = questRevision;
+
+            //checkPeriod == false면 기간을 체크하지 않는다.
+            if (checkPeriod && MetaHelper.GameConfigMeta.QuestMailStoragePeriod > 0)
+            {
+                attribute.ExpireTime = now_dt.AddSeconds(MetaHelper.GameConfigMeta.QuestMailStoragePeriod);
+            }
+            
+            attribute.newEntityAttribute();
+
+            var log_invoker = new QuestMailBusinessLog(attribute, QuestMailLogType.Create);
+
+            return (quest_mail, log_invoker);
+        }
+
+
+        public async Task<Result> setQuestMailFromDoc(QuestMailDoc doc)
+        {
+            var result = new Result();
+            var quest_mail_attrib = doc.getAttrib<QuestMailAttrib>();
+            NullReferenceCheckHelper.throwIfNull(quest_mail_attrib, () => $"quest_mail_attrib is null !!!");
+
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            ServerCommon.QuestMail mail = new ServerCommon.QuestMail (owner);
+            //await mail.onInit();
+            var mail_attribute = mail.getEntityAttribute<QuestMailAttribute>();
+            NullReferenceCheckHelper.throwIfNull(mail_attribute, () => $"mail_attribute is null !!!");
+
+            mail_attribute.QuestId = quest_mail_attrib.QuestId;
+            mail_attribute.QuestRevision = quest_mail_attrib.QuestRevision;
+            mail_attribute.CreateTime = quest_mail_attrib.CreateTime;
+            mail_attribute.ExpireTime = quest_mail_attrib.ExpireTime;
+            mail_attribute.IsRead = quest_mail_attrib.IsRead;
+
+            mail_attribute.syncOriginDocBaseWithNewDoc<QuestMailAttribute>(doc);            
+
+            var quest_type = await QuestMetaHelper.getQuestType(owner, quest_mail_attrib.QuestId, quest_mail_attrib.QuestRevision);
+            m_quest_mails.TryAdd((quest_type, quest_mail_attrib.QuestId), mail);
+
+            return result;
+        }
+
+        public async Task addNewQuestMails(List<ServerCommon.QuestMail> questMails)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            foreach (var quest_mail in questMails)
+            {
+                var quest_mail_attribute = quest_mail.getEntityAttribute<QuestMailAttribute>();
+                NullReferenceCheckHelper.throwIfNull(quest_mail_attribute, () => $"quest_mail_attribute is null !!!");
+                //여기에 Revision이 들어야가되면 0 대신 revision 값 셋팅 해야함
+                var quest_type = await QuestMetaHelper.getQuestType(player, quest_mail_attribute.QuestId, 0);
+                m_quest_mails.TryAdd((quest_type, quest_mail_attribute.QuestId), quest_mail);
+            }
+        }
+
+        public void setQuestMailLoadedAll()
+        { 
+            m_is_quest_mail_loaded = true;
+        }
+
+        public bool isMailLoadedAll()
+        {
+            return m_is_quest_mail_loaded;
+        }
+
+        public Result GS2C_NTF_RECEIVED_QUEST_MAIL(QuestMailInfo mailInfo)
+        { 
+            var result = new Result();
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            ClientToGame ntf_packet = new();
+            ntf_packet.Message = new();
+            ntf_packet.Message.ReceiveQuestMailNoti = new();
+            ntf_packet.Message.ReceiveQuestMailNoti.QuestMailInfo.Add(mailInfo);
+
+
+            GameServerApp.getServerLogic().onSendPacket(owner, ntf_packet);
+            return result;
+        }
+
+        public async Task<(Result, ServerCommon.QuestMail, ILogInvoker)> sendQuestMail(UInt32 questId)
+        {
+            (var result, var quest_mails, var log_invokers) = await sendQuestMails(new List<UInt32>() { questId } );
+            return (result, quest_mails[0], log_invokers[0]);
+        }
+
+
+        public async Task<(List<AcceptQuestVariable>, List<ServerCommon.QuestMail>, List<ILogInvoker>)> questMailSendOrForceAccept(List<UInt32> questIds)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            List<UInt32> mail_quests = new();
+
+            List<AcceptQuestVariable> accept_quest_variables = new();
+            List<ServerCommon.QuestMail> send_quest_mails = new();
+            List<ILogInvoker> log_invokers = new();
+            var result = new Result();
+            foreach (var quest_id in questIds)
+            {
+                (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
+                if (result.isFail()) continue;
+                var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+                NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+                if (quest_base_info.AssignType.Equals(nameof(EAssignType.MAIL)) && quest_base_info.ForceAccept == false)
+                {
+                    mail_quests.Add(quest_id);
+                    continue;
+                }
+                else if (quest_base_info.AssignType.Equals(nameof(EAssignType.MAIL)) && quest_base_info.ForceAccept == true)
+                {
+                    var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
+                    (result, var quest_var) = await quest_accept_action.questAccept(quest_id);
+                    if (result.isFail()) continue;
+                    NullReferenceCheckHelper.throwIfNull(quest_var, () => $"quest_var is null !!!");
+                    accept_quest_variables.Add(quest_var);
+                }
+            }
+            if (mail_quests.Count > 0)
+            {
+                (result, var quest_mails, log_invokers) = await sendQuestMails(mail_quests);
+                if(result.isSuccess()) send_quest_mails.AddRange(quest_mails);
+            }
+
+            return (accept_quest_variables, send_quest_mails, log_invokers);
+        }
+
+        public async Task questMailSendOrForceAcceptWithTransaction(QuestRewardHandler questRewardHandler, List<UInt32> questIds)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            List<UInt32> mail_quests = new();
+
+            foreach (UInt32 quest_id in questIds)
+            {
+                (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
+                if (result.isFail()) continue;
+                var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+                NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+                if (quest_base_info.QuestType.Equals(nameof(MetaAssets.EQuestType.NORMAL)) && quest_base_info.OncePeriodRangeType.Equals(OncePeriodRangeType.Nolimit))
+                {
+                    continue;
+                }
+                
+                //Nolimit 아님 Normal 중에 이미 한번 받은 이력있는건 더 못받는다..
+                if (quest_base_info.QuestType.Equals(nameof(MetaAssets.EQuestType.NORMAL)) && questRewardHandler.m_has_already_end_quest)
+                {
+                    continue;
+                }
+                
+
+                if (quest_base_info.AssignType.Equals(nameof(MetaAssets.EAssignType.MAIL)) && quest_base_info.ForceAccept == false)
+                {
+                    mail_quests.Add(quest_id);
+                    continue;
+                }
+                else if (quest_base_info.AssignType.Equals(nameof(MetaAssets.EAssignType.MAIL)) && quest_base_info.ForceAccept == true)
+                {
+                    var quest_action = player.getEntityAction<QuestAction>();
+                    await quest_action.questForceAcceptWithTransaction(quest_id);
+                }
+            }
+
+
+            if (mail_quests.Count > 0)
+            {
+                (var result, var quest_mails) = await sendQuestMailsWithTransaction(mail_quests);
+            }
+        }
+       
+    }
+
+
+}

GameServer/Contents/Quest/Action/QuestNPCDialogueAction.cs

@@ -0,0 +1,107 @@
+using Amazon.CloudWatchLogs.Model;
+using MetaAssets;
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class QuestNPCDialogueAction : EntityActionBase
+    {
+        public QuestNPCDialogueAction(EntityBase owner) 
+            : base(owner)
+        {
+        }
+
+        public override Task<Result> onInit()
+        {
+            var result = new Result();
+            return Task.FromResult(result);
+        }
+        public async Task<Result> checkQuestDialogue(string dialogue, string dialogueResult)
+        {
+            var result = new Result();
+
+            if (false == QuestManager.It._QuestDialogueGroup.TryGetValue((dialogue, dialogueResult), out var questIds)) return result;
+            
+            foreach (var questId in questIds)
+            {
+                await questAcceptByNpcDialogue(questId, dialogue, dialogueResult);
+            }
+            return result;
+        }
+
+        public async Task questAcceptByNpcDialogue(UInt32 questId, string dialogue, string dialogueresult)
+        {
+            (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+            if (result.isFail()) return;
+            var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+            NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+            
+            var end_quest_action = owner.getEntityAction<EndQuestAction>();
+            var quest_action = owner.getEntityAction<QuestAction>();
+
+            var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);
+
+            //해당 퀘스트를 내가 완료했는지 체크, 재할당 가능한지는 확인 필요하다
+            result = end_quest_action.endQuestCheck(quest_type, questId, 0);
+            if(result.isFail()) return;
+
+            result = quest_action.hasQuest(quest_type, questId);
+            if (result.isFail()) return;
+
+            result = quest_action.assignableQuestCheckByQuestType(quest_type);
+            if (result.isFail()) return;
+
+
+            //데이터 할당
+            result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "QuestAcceptByNpcDialogue", delegateQuestAcceptByNpcDialogue);
+            if (result.isFail())
+            {
+                string err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {owner.toBasicString()}";
+                Log.getLogger().error(err_msg);
+                return;
+            }
+
+            async Task<Result> delegateQuestAcceptByNpcDialogue() => await questAcceptByNpcDialogue(owner, quest_base_info, dialogue, dialogueresult);
+        }
+
+        private async Task<Result> questAcceptByNpcDialogue(Player owner, QuestBaseInfo questMetaInfo, string dialogue, string dialogueresult)
+        {
+            var quest_accept_action = owner.getEntityAction<QuestAcceptAction>();
+            (var result, var quest_accept_var) = quest_accept_action.acceptQuestByNpcDialogue(questMetaInfo);
+            if (result.isFail()) return result;
+
+            NullReferenceCheckHelper.throwIfNull(quest_accept_var.m_new_quest_nullable, () => $"quest_accept_var.m_new_quest_nullable is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.QuestMainAssignByDialogue, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+            }
+            batch.appendBusinessLog(new QuestAcceptByDialogueBusinessLog(questMetaInfo.QuestId, questMetaInfo.QuestRevision, dialogue, dialogueresult));
+
+            result = await QueryHelper.sendQueryAndBusinessLog(batch);
+            if (result.isFail()) return result;
+
+
+            var quest_action = owner.getEntityAction<QuestAction>();
+            quest_action.addNewQuest(questMetaInfo.QuestId, quest_accept_var.m_new_quest_nullable);
+            await owner.send_GS2C_NTF_QUEST_UPDATE(questMetaInfo.QuestId, 0, new(), true);
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+    }
+}

GameServer/Contents/Quest/Action/QuestRefuseAction.cs

@@ -0,0 +1,63 @@
+using MetaAssets;
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class QuestRefuseAction : EntityActionBase
+    {
+        public QuestRefuseAction(EntityBase owner) 
+            : base(owner)
+        {}
+
+        public override async Task<Result> onInit()
+        {
+            await Task.CompletedTask;
+
+            var result = new Result();
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public async Task<Result> refuseQuestConditionCheck(UInt32 questId)
+        {
+            var result = new Result();
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var quest_action = owner.getEntityAction<QuestAction>();
+            var quest_mail_action = owner.getEntityAction<QuestMailAction>();
+
+            (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
+            if (result.isFail()) return result;
+            var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
+
+            NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+            if (false == quest_base_info.QuestType.Equals(nameof(EQuestType.NORMAL)))
+            {
+                result.setFail(ServerErrorCode.QuestRefuseOnlyNormal, $"QuestID : {questId}, questType not normal");
+                return result;
+            }
+
+            if (true == quest_base_info.AssignType.Equals(EAssignType.MAIL.ToString()))
+            {
+                var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);
+                result = quest_mail_action.hasQuestMail(quest_type, questId, true);
+                if (result.isFail()) return result;
+            }
+
+            return result;
+        }
+    }
+}

GameServer/Contents/Quest/Action/QuestRewardAction.cs

@@ -0,0 +1,270 @@
+
+using ServerBase;
+using ServerCore;
+using ServerCommon;
+using MetaAssets;
+
+
+using static ClientToGameMessage.Types;
+
+
+using Guid = System.Guid;
+
+
+
+namespace GameServer;
+
+
+internal class QuestRewardAction : EntityActionBase
+{
+    public QuestRewardAction(EntityBase owner)
+        : base(owner)
+    {
+    }
+
+    public override Task<Result> onInit()
+    {
+        var result = new Result();
+        return Task.FromResult(result);
+    }
+
+    public async Task processAfterReward(QuestRewardHandler questRewardHandler)
+    {
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var quest_base_info = questRewardHandler.m_quest_meta_info;
+        ArgumentNullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
+
+        var assignable_quests = quest_base_info.AssignableQuestsAfterEnd;
+        
+        var quest_mail_action = player.getEntityAction<QuestMailAction>();
+        await quest_mail_action.questMailSendOrForceAcceptWithTransaction(questRewardHandler, assignable_quests);
+
+
+        //api 서버에 ugq complete 전송
+        var server_logic = GameServerApp.getServerLogic();
+        var ugq_api_manager = server_logic.GetUqgApiManager();
+        
+        var quest_id = questRewardHandler.m_quest_id;
+        var quest_revision = questRewardHandler.m_quest_revision;
+
+        if (questRewardHandler.m_ugq_game_data is not null && questRewardHandler.m_is_repeat_ugq_quest == false)
+        {
+            var cost = questRewardHandler.m_ugq_game_data.Cost;
+            var api_result = await ugq_api_manager.setUgqQuestCompleted(player.getUserGuid(), quest_id, quest_revision, cost, player.getLanguageType());
+            if (api_result.isFail())
+            {
+                //로그만 남긴다. 
+                Log.getLogger().error($"Failed to setUgqQuestCompleted : {api_result.toBasicString()} - {player.toBasicString()}");
+            }
+        }
+
+    }
+    public async Task normalQuestCheckInitialize()
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var quest_mail_action = owner.getEntityAction<QuestMailAction>();
+
+        //메일 지급 가능한 퀘스트 체크
+        var my_normal_mail_cnt = (await quest_mail_action.getNormalMailSet()).Count;
+        HashSet<UInt32> assignable_mail_set = await quest_mail_action.getAssignableMailSet();
+        
+        //메일 보낼 수 있는 퀘스트가 없으면 return;
+        if (assignable_mail_set.Count < 1) { return; }
+
+        //메일 보낼 수 있는 퀘스트가 있지만 이미 메일이 꽉찼으면 활성화 안해준다. 
+        if (MetaHelper.GameConfigMeta.MaxQuestSendMail <= my_normal_mail_cnt) return;
+
+        //이미 리프레시 체크 중인 유저는 그냥 리턴
+        if (QuestManager.It.m_normal_quest_check_users.ContainsKey(owner.getUserGuid())) return;
+
+        var repeat_quest_action = owner.getEntityAction<RepeatQuestAction>();
+
+        DateTime nowDT = DateTime.UtcNow;
+        var nextTime = nowDT.AddMinutes(MetaHelper.GameConfigMeta.CooltimeNormalQuestSendMail);
+
+        var fn_quest_task_update = async delegate ()
+        {
+            var result = new Result();
+            
+            Int32 is_checking = 1;
+            repeat_quest_action.setRepeatQuestInfo(nextTime, is_checking);
+
+            var server_logic = GameServerApp.getServerLogic();
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>( owner
+                                                                 , LogActionType.QuestMainRepeatTimeInit
+                                                                 , server_logic.getDynamoDbClient() );
+            {
+                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+            }
+
+            batch.appendBusinessLog(new RepeatQuestBusinessLog(nextTime, is_checking));
+            result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+            return result;
+        };
+
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "RepeatQuestInfoUpdate", fn_quest_task_update);
+        if (result.isFail())
+        {
+            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {owner.toBasicString()}";
+            Log.getLogger().error(err_msg);
+        }
+
+        //여기서,  활성화 되고 체킹중인 유저에 대해서 QuestManager 에 추가(Initialize 시점이니 여기서 셋팅)
+        QuestManager.It.m_normal_quest_check_users.TryAdd(owner.getUserGuid(), 1);
+    }
+        
+    public Result questRewardConditionCheck(ref QuestRewardHandler questRewardHandler)
+    {
+        var result = new Result();
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var quest_action = owner.getEntityAction<QuestAction>();
+
+        var quest_id = questRewardHandler.m_quest_id;
+        var quest_revision = questRewardHandler.m_quest_revision;
+        var quest = questRewardHandler.m_quest;
+        ArgumentNullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");
+
+        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+        if (quest_attribute.IsComplete == 0)
+        {
+            var err_msg = $"Quest Not Completed QuestID : {quest_id},  owner : {owner.toBasicString()}";
+            result.setFail(ServerErrorCode.QuestNotComplete, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        //대체 보상있는 경우 해당 보상정보로 변경
+        if (quest_attribute.ReplacedRewardGroupId != 0) questRewardHandler.m_replaced_reward_group_id = quest_attribute.ReplacedRewardGroupId;
+
+        List<RewardMetaData> reward_meta_datas = new List<RewardMetaData>();
+        //Meta에 보상 정보 없는 경우 에러 처리
+        if (false == MetaData.Instance._RewardMetaTable.TryGetValue(questRewardHandler.m_replaced_reward_group_id, out var rewardList))
+        {
+            //ugq에서 m_replaced_reward_group_id 이 0일 수 있다... 일단 여기에 넣고 나중에 reward 관련 일반화 다시 해야될듯...
+            if (questRewardHandler.m_replaced_reward_group_id == 0)
+            {
+                reward_meta_datas = new();
+            }
+            else 
+            {
+                var err_msg = $"_RewardDataTable not exist info rewardGroupId = {questRewardHandler.m_replaced_reward_group_id}, owner : {owner.toBasicString()}";
+                result.setFail(ServerErrorCode.RewardInfoNotExist, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+        }
+        else
+        {
+            reward_meta_datas.AddRange(rewardList);
+            //endquest가 존재(반복진행)하고 퀘스트가 ugq이면 보상 그룹은 0으로 처리...아 이것도 코드 바꾸고 싶다...
+            var end_quest_action = owner.getEntityAction<EndQuestAction>();
+            var end_quest = end_quest_action.getEndQuest(quest_id, quest_revision);
+            bool is_already_cleared_ugq = (end_quest is not null && end_quest.isUgq() == true);
+            if (is_already_cleared_ugq)
+            {
+                questRewardHandler.m_is_repeat_ugq_quest = true;
+                questRewardHandler.m_replaced_reward_group_id = 0;
+                reward_meta_datas = new();
+            }
+            dailyRewardCountCheck(ref questRewardHandler, is_already_cleared_ugq);
+        }
+        
+        foreach (var reward in reward_meta_datas)
+        {
+            questRewardHandler.m_rewards.Add(reward.Reward);
+        }
+        return result;
+    }
+
+    private void dailyRewardCountCheck(ref QuestRewardHandler questRewardHandler, bool isAlreadyClearedUgq)
+    {
+        if (isAlreadyClearedUgq) return;
+
+        if (questRewardHandler.m_ugq_game_data is null) return;
+        
+        ArgumentNullReferenceCheckHelper.throwIfNull(questRewardHandler.m_quest_meta_info, () => $"questRewardHandler.m_quest_meta_info is null !!!");
+
+        if (questRewardHandler.m_quest_meta_info.QuestRevision == 0) return;
+        //ugq daily 반복보상 체크
+        var ugq_daily_reward_count_attribute = getOwner().getEntityAttribute <UgqDailyRewardCountAttribute>();
+        NullReferenceCheckHelper.throwIfNull(ugq_daily_reward_count_attribute, () => $"ugq_daily_reward_count_attribute is null !!!");
+
+        int max_cnt = 10;
+        var bonus_cnt= ugq_daily_reward_count_attribute.getDailyRewardByGrade(questRewardHandler.m_ugq_game_data.GradeType);
+
+        (max_cnt, questRewardHandler.m_ugq_daily_bonus_gold) = UgqMetaHelper.getUgqDailyRewardMaxCountByGrade(questRewardHandler.m_ugq_game_data.GradeType);  
+        
+        if (bonus_cnt < max_cnt)
+        {
+            questRewardHandler.m_has_ugq_daily_reward = true; 
+
+            RewardMutable reward_mutable = new RewardMutable();
+            reward_mutable.Currency = new CurrencyRewardMutable()
+            {
+                Id = (int)CurrencyType.Gold,
+                Value =  questRewardHandler.m_ugq_daily_bonus_gold
+            };
+
+            MetaAssets.Reward reward_gold = new MetaAssets.Reward(reward_mutable);
+            questRewardHandler.m_rewards.Add(reward_gold);
+        }
+    }
+
+    public override void onClear()
+    {
+        return;
+    }
+
+    public Result setUgqDailyRewardCountFromDoc(UgqDailyRewardCountDoc doc)
+    {
+        var result = new Result();
+        
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var ugq_daily_reward_attribute = owner.getEntityAttribute<UgqDailyRewardCountAttribute>();
+        
+        if (ugq_daily_reward_attribute is null)
+        {
+            var err_msg = $"Fail to get ugq_daily_reward_attribute";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+        
+        if (false == doc.getAttribWrappers().TryGetValue(typeof(UgqDailyRewardCountAttrib), out var to_copy_doc_attrib))
+        {
+            var err_msg = $"Fail to get UgqDailyRewardCountAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+        
+        var attrib_base = to_copy_doc_attrib.getAttribBase();
+        var doc_attrib = attrib_base as UgqDailyRewardCountAttrib;
+        if (doc_attrib is null)
+        {
+            var err_msg = $"Fail to get UgqDailyRewardCountAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            return result;
+        }
+
+        foreach (var reward_cnt in doc_attrib.m_ugq_daily_reward_count)
+        {
+            ugq_daily_reward_attribute.m_ugq_daily_reward_count.AddOrUpdate(reward_cnt.Key, reward_cnt.Value, (key, oldValue) => reward_cnt.Value);
+        }
+
+        ugq_daily_reward_attribute.m_next_refresh_time = doc_attrib.m_next_refresh_time;
+        ugq_daily_reward_attribute.m_ugq_daily_reward_count_doc_nullable = doc;
+
+        
+        
+        return result;
+         
+    }
+}

GameServer/Contents/Quest/Action/QuestTaskUpdateAction.cs

@@ -0,0 +1,263 @@
+using Amazon.CloudWatchLogs.Model;
+using Amazon.Runtime.Internal;
+using Amazon.S3.Model;
+using Google.Protobuf.WellKnownTypes;
+using MetaAssets;
+using Newtonsoft.Json;
+using Org.BouncyCastle.Asn1.Ocsp;
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static ClientToGameRes.Types;
+
+namespace GameServer
+{
+    public class QuestTaskUpdateAction : EntityActionBase
+    {
+        public QuestTaskUpdateAction(EntityBase owner)
+            : base(owner)
+        {
+        }
+
+        public override Task<Result> onInit()
+        {
+            var result = new Result();
+            return Task.FromResult(result);
+        }
+
+        private Result taskFunctionProgress(QuestTaskUpdateHandler questTaskUpdateHandler)
+        {
+            ArgumentNullReferenceCheckHelper.throwIfNull(questTaskUpdateHandler.m_quest, () => $"questTaskUpdateHandler.m_quest is null !!!");
+
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var quest_task = new QuestClientSide(owner);
+            var quest = questTaskUpdateHandler.m_quest;
+
+            var result = quest_task.questTaskFunctionProgress(owner, ref questTaskUpdateHandler);
+            if(result.isFail()) return result;
+
+            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+
+            if (quest_attribute.CurrentTaskComplete == 1 && quest_attribute.IsComplete == 0)
+            {
+                result = questNextTaskUpdate(questTaskUpdateHandler);
+                if(result.isFail()) return result;
+            }
+            quest_attribute.modifiedEntityAttribute();
+
+            return result;
+        }
+
+        private async Task<Result> rewardUpdate(QuestTaskUpdateHandler questTaskUpdateHandler)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            IReward reward_proc = new QuestTaskReward(owner, owner.getUserGuid(), questTaskUpdateHandler);
+
+            var result = await RewardManager.It.proceedRewardProcess(reward_proc);
+            if (result.isFail()) return result;
+            return result;
+        }
+
+        private async Task<Result> delteItemUpdate(QuestTaskUpdateHandler questTaskUpdateHandler)
+        {
+            var result = new Result();
+
+            //아이템 삭제 처리
+            var delete_items = questTaskUpdateHandler.m_deletable_items;
+            foreach (var item in delete_items)
+            {
+                var item_id = item.Key;
+                var item_count = item.Value;
+
+                var owner = getOwner() as Player;
+                NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+                var inventory_action = owner.getEntityAction<InventoryActionBase>();
+                (result, var deleted_item) = await inventory_action.tryDeleteItemByMetaId((uint)item_id, (ushort)item_count);
+                if (result.isFail()) 
+                {
+                    var err_msg = $"delteItemUpdate error delteitem : {JsonConvert.SerializeObject(item)}, owner : {owner.toBasicString()}";
+                    Log.getLogger().error(err_msg);
+                    return result;
+                }
+                questTaskUpdateHandler.m_deleted_items.AddRange(deleted_item);
+            }   
+            return result;
+        }
+
+        public Result questNextTaskUpdate(QuestTaskUpdateHandler questTaskUpdateHandler)
+        {
+            ArgumentNullReferenceCheckHelper.throwIfNull(questTaskUpdateHandler.m_quest_meta_info, () => $"questTaskUpdateHandler.m_quest_meta_info is null !!!");
+            ArgumentNullReferenceCheckHelper.throwIfNull(questTaskUpdateHandler.m_quest, () => $"questTaskUpdateHandler.m_quest is null !!!");
+
+            var result = new Result();
+
+            //var task_group = questTaskUpdateHandler.m_quest_task_group;
+            var next_task_num = questTaskUpdateHandler.m_next_task_number;
+
+            var task_group_list = questTaskUpdateHandler.m_quest_meta_info.QuestTaskGroupList;
+            if (false == task_group_list.TryGetValue(next_task_num, out var questTaskInfo))
+            {
+                var err_msg = $"questEventInfo InvalidData questId = {questTaskUpdateHandler.m_quest_id}, next_task_num : {next_task_num}";
+                result.setFail(ServerErrorCode.QuestInvalidValue, err_msg);
+                return result;                
+            }
+
+            var quest_attribute = questTaskUpdateHandler.m_quest.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+            quest_attribute.CurrentTaskNum = next_task_num;
+            quest_attribute.CurrentTaskComplete = 0;
+
+            DateTime now = DateTime.UtcNow;
+            quest_attribute.TaskStartTime = now;
+            quest_attribute.ActiveEvents.Clear();
+            quest_attribute.ActiveEvents.AddRange(questTaskInfo.EventStringList);
+            quest_attribute.HasTimer = 0;
+            quest_attribute.TimerCompleteTime = now;
+            quest_attribute.CompletedIdxStrings.Clear();
+
+            if (questTaskInfo.HasCounter)
+            {
+                quest_attribute.HasCounter = 1;
+                quest_attribute.MaxCounter = questTaskInfo.MaxCounter;
+                quest_attribute.MinCounter = questTaskInfo.MinCounter;
+                quest_attribute.CurrentCounter = questTaskInfo.MinCounter;
+            }
+            else
+            {
+                quest_attribute.HasCounter = 0;
+                quest_attribute.MaxCounter = 0;
+                quest_attribute.MinCounter = 0;
+                quest_attribute.CurrentCounter = 0;
+            }
+            return result;
+        }
+
+
+        public Result taskUpdateConditionCheck(ref QuestTaskUpdateHandler questTaskUpdateHandler)
+        {
+            ArgumentNullReferenceCheckHelper.throwIfNull(questTaskUpdateHandler.m_quest_meta_info, () => $"questTaskUpdateHandler.m_quest_meta_info is null !!!");
+            ArgumentNullReferenceCheckHelper.throwIfNull(questTaskUpdateHandler.m_quest, () => $"questTaskUpdateHandler.m_quest is null !!!");
+
+            var result = new Result();
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var quest_id = questTaskUpdateHandler.m_quest_id;
+
+            var server_logic = GameServerApp.getServerLogic();
+            var quest_action = owner.getEntityAction<QuestAction>();
+
+            var quest_type = questTaskUpdateHandler.m_quest_type;
+            var quest = questTaskUpdateHandler.m_quest;
+
+            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
+            if (quest_attribute.IsComplete == 1)
+            {
+                result.setFail(ServerErrorCode.QuestAlreadyComplete, $"Already Complete Quest QuestID : {quest_id}");
+                return result;
+            }
+
+            var active_event = questTaskUpdateHandler.m_active_event;
+            if (false == quest_attribute.ActiveEvents.Contains(active_event))
+            {
+                string err_msg = $"ActiveIdxList info Invalie questId : {quest_id}, activeEvent : {active_event} User QuestInfo : {JsonConvert.SerializeObject(quest_attribute)}";
+                result.setFail(ServerErrorCode.QuestMailNotExist, err_msg);
+                return result;
+            }
+
+            
+            if (false == questTaskUpdateHandler.m_quest_meta_info.QuestTaskGroupList.TryGetValue(quest_attribute.CurrentTaskNum, out var questTaskInfo))
+            {
+                string err_msg = $"questBaseInfo.QuestTaskGroupList InvalidData CurrentTaskNum : {quest_attribute.CurrentTaskNum}";
+                result.setFail(ServerErrorCode.QuestInvalidValue, err_msg);
+                return result;
+            }
+            questTaskUpdateHandler.m_quest_task_group = questTaskInfo;
+
+            result = QuestMetaHelper.getQuestTaskEventGroupByEventString(questTaskInfo, active_event, out var questEventInfo);
+            if(result.isFail()) return result;
+
+            NullReferenceCheckHelper.throwIfNull(questEventInfo, () => $"questEventInfo is null !!!");
+
+            EQuestEventTargetType targetType = EnumHelper.convertEnumTypeAndValueStringToEnum(questEventInfo.EventTarget, EQuestEventTargetType.NONE);
+            EQuestEventNameType nameType = EnumHelper.convertEnumTypeAndValueStringToEnum(questEventInfo.EventName, EQuestEventNameType.NONE);
+
+            if (false == checkClientSideEvent(targetType, nameType))
+            {
+                string err_msg = $"scriptDataList does not match EQuestEventTargetType questId : {quest_id}, targetType : {targetType.ToString()}, nameType : {nameType.ToString()}";
+                result.setFail(ServerErrorCode.QuestInvalidValue, err_msg);
+                return result;
+            }
+
+            questTaskUpdateHandler.m_target_type = targetType;
+            questTaskUpdateHandler.m_name_type = nameType;
+
+            return result;
+        }
+
+
+        public bool checkClientSideEvent(EQuestEventTargetType target, EQuestEventNameType nameType)
+        {
+            if (target.Equals(EQuestEventTargetType.GUI) && nameType.Equals(EQuestEventNameType.POPUP)) return true;
+            if (target.Equals(EQuestEventTargetType.CONCERT) && nameType.Equals(EQuestEventNameType.STARTED)) return true;
+            if (target.Equals(EQuestEventTargetType.CONCERT) && nameType.Equals(EQuestEventNameType.ENDED)) return true;
+            if (target.Equals(EQuestEventTargetType.CUTSCENE)) return true;
+            if (target.Equals(EQuestEventTargetType.DIALOGUE)) return true;
+            if (target.Equals(EQuestEventTargetType.MANNEQUIN) && nameType.Equals(EQuestEventNameType.USED)) return true;
+            if (target.Equals(EQuestEventTargetType.MOVEMENT) && nameType.Equals(EQuestEventNameType.FEVER)) return true;
+            if (target.Equals(EQuestEventTargetType.MOVEMENT)) return true;
+            if (target.Equals(EQuestEventTargetType.NPC)) return true;
+            if (target.Equals(EQuestEventTargetType.SOCIALACTION) && nameType.Equals(EQuestEventNameType.ACTIVED)) return true;
+            if (target.Equals(EQuestEventTargetType.SPECIALGUIDE)) return true;
+            if (target.Equals(EQuestEventTargetType.TAXI) && nameType.Equals(EQuestEventNameType.USED)) return true;
+            if (target.Equals(EQuestEventTargetType.TRIGGER)) return true;
+            if (target.Equals(EQuestEventTargetType.VIDEO)) return true;
+            if (target.Equals(EQuestEventTargetType.INTERIORMODE) && nameType.Equals(EQuestEventNameType.STOPPED)) return true;
+            if (target.Equals(EQuestEventTargetType.BEACONDIALOGUE) && nameType.Equals(EQuestEventNameType.SENDED)) return true;
+            if (target.Equals(EQuestEventTargetType.BEACONDIALOGUE) && nameType.Equals(EQuestEventNameType.RECEIVED)) return true;
+            if (target.Equals(EQuestEventTargetType.WAITING)) return true;
+            if (target.Equals(EQuestEventTargetType.PROP) && nameType.Equals(EQuestEventNameType.SWITCHED)) return true;
+
+            return false;
+        }
+
+        public async Task<Result> questTaskUpdate(QuestTaskUpdateHandler questTaskUpdateDataRef)
+        {
+            var result = new Result();
+            result = taskFunctionProgress(questTaskUpdateDataRef);
+            if (result.isFail()) return result;
+
+            result = await rewardUpdate(questTaskUpdateDataRef);
+            if (result.isFail()) return result;
+
+            result = await delteItemUpdate(questTaskUpdateDataRef);
+            if (result.isFail()) return result;
+
+            
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        
+
+
+    }
+}

GameServer/Contents/Quest/Action/RepeatQuestAction.cs

@@ -0,0 +1,109 @@
+
+using Amazon.DynamoDBv2.Model;
+using Google.Protobuf.WellKnownTypes;
+using ServerCommon;
+using ServerCore; using ServerBase;
+
+namespace GameServer
+{
+    public class RepeatQuestAction : EntityActionBase
+    {
+        public RepeatQuestAction(EntityBase owner)
+            : base(owner)
+        {}
+
+        public override async Task<Result> onInit()
+        {
+            await Task.CompletedTask;
+
+            var result = new Result();
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public Int32 isChecking()
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            var repeat_quest_attribute = player.getEntityAttribute<RepeatQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(repeat_quest_attribute, () => $"repeat_quest_attribute is null !!!");
+
+            return repeat_quest_attribute.m_is_checking;
+        }
+
+        public DateTime getNextAllocateTime()
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            var repeat_quest_attribute = player.getEntityAttribute<RepeatQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(repeat_quest_attribute, () => $"repeat_quest_attribute is null !!!");
+
+            return repeat_quest_attribute.m_next_allocate_time;
+        }
+
+        public void setRepeatQuestInfo(DateTime nextAllocateTime, Int32 isChecking)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+            var repeat_quest_attribute = player.getEntityAttribute<RepeatQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(repeat_quest_attribute, () => $"repeat_quest_attribute is null !!!");
+            repeat_quest_attribute.m_next_allocate_time = nextAllocateTime;
+            repeat_quest_attribute.m_is_checking = isChecking;
+            repeat_quest_attribute.modifiedEntityAttribute();
+        }
+
+        public Result setRepeatQuestFromDoc(RepeatQuestDoc doc)
+        {
+            var result = new Result();
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            if (false == doc.getAttribWrappers().TryGetValue(typeof(RepeatQuestAttrib), out var to_copy_doc_attrib))
+            {
+                var err_msg = $"Fail to get QuestAttrib";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+            
+            var attrib_base = to_copy_doc_attrib.getAttribBase();
+            var doc_attrib = attrib_base as RepeatQuestAttrib;
+            if (doc_attrib is null)
+            {
+                var err_msg = $"Fail to get QuestAttrib";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+
+            var repeat_quest_attribute = owner.getEntityAttribute<RepeatQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(repeat_quest_attribute, () => $"repeat_quest_attribute is null !!!");
+
+            repeat_quest_attribute.m_next_allocate_time = doc_attrib.m_next_allocate_time;
+            repeat_quest_attribute.m_is_checking = doc_attrib.m_is_checking;
+
+            repeat_quest_attribute.syncOriginDocBaseWithNewDoc<RepeatQuestAttribute>(doc);
+
+            return new Result();
+        }
+
+        public void checkAndAddNormalQuestCheckPool()
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var repeat_quest_attribute = player.getEntityAttribute<RepeatQuestAttribute>();
+            NullReferenceCheckHelper.throwIfNull(repeat_quest_attribute, () => $"repeat_quest_attribute is null !!!");
+
+            if (repeat_quest_attribute.m_is_checking == 1)
+            {
+                QuestManager.It.m_normal_quest_check_users.TryAdd(player.getUserGuid(), 1);
+                return;
+            }            
+        }
+    }
+
+}