초기커밋

GameServer/Contents/Friend/Action/FriendAction.cs

@@ -0,0 +1,30 @@
+using Newtonsoft.Json;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+using System.Collections.Concurrent;
+
+namespace GameServer
+{
+    public class FriendAction : EntityActionBase
+    {
+        public FriendAction(Friend owner)
+            : base(owner)
+        {
+        }
+
+        public override async Task<Result> onInit()
+        {
+            await Task.CompletedTask;
+
+            var result = new Result();
+
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+    }
+}

GameServer/Contents/Friend/Action/FriendAgentAction.cs

@@ -0,0 +1,295 @@
+using Nettention.Proud;
+using Newtonsoft.Json;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer;
+
+public class FriendAgentAction : EntityActionBase
+{
+    private ConcurrentDictionary<string, Friend> m_friends = new();
+
+    public FriendAgentAction(Player owner) 
+        : base(owner)
+    {
+    }
+
+    public override async Task<Result> onInit()
+    {
+        await Task.CompletedTask;
+
+        var result = new Result();
+
+        return result;
+    }
+
+    public override void onClear()
+    {
+        m_friends.Clear();
+    }
+
+    public async Task<Result> loadFriends()
+    {
+        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 DBQFriendsReadAll(owner.getUserGuid()));
+        }
+        var result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+        return result;
+    }
+
+
+    public async Task<Result> setFriendsFromDoc(FriendDoc doc)
+    {
+        var result = new Result();
+        var owner = getOwner();
+        Friend friend = new Friend(owner);
+
+        var attribute = friend.getEntityAttribute<FriendAttribute>();
+        if (attribute is null)
+        {
+            var err_msg = $"Fail to get FriendAttribute";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+        if (false == doc.getAttribWrappers().TryGetValue(typeof(FriendAttrib), out var to_copy_doc_attrib))
+        {
+            var err_msg = $"Fail to get FriendAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+        var attrib_base = to_copy_doc_attrib.getAttribBase();
+        var doc_attrib = attrib_base as FriendAttrib;
+        if (doc_attrib is null)
+        {
+            var err_msg = $"Fail to get FriendAttrib";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        var player = owner as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        attribute.UserGuid = player.getUserGuid();
+        attribute.FriendGuid = doc_attrib.FriendGuid;
+        attribute.CreateTime = doc_attrib.CreateTime;
+        attribute.FolderName = doc_attrib.FolderName;
+        attribute.IsNew = doc_attrib.IsNew;
+
+        if (doc_attrib.FriendGuid.Equals(string.Empty))
+        {
+            var err_msg = $"FriendGuid is Empty, {toBasicString()}";
+            result.setFail(ServerErrorCode.FriendInfoNotExist, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        if (doc_attrib.FriendGuid.Equals(attribute.UserGuid))
+        {
+            var err_msg = $"FriendGuid and UserGuid is Equals, {toBasicString()}";
+            result.setFail(ServerErrorCode.FriendInfoNotExist, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        (result, var nickname_attrib) = await NicknameDoc.findNicknameFromGuid(doc_attrib.FriendGuid);
+        if(result.isFail())
+        {
+            return result;
+        }
+        NullReferenceCheckHelper.throwIfNull(nickname_attrib, () => $"nickname_attrib is null !!!");
+        attribute.Nickname = nickname_attrib.Nickname;
+
+        m_friends.AddOrUpdate(doc_attrib.FriendGuid, friend, (key, oldValue) => friend);
+
+        return result;
+    }
+
+    public async Task<List<FriendInfo>> getFriendsInfo()
+    {
+        return await convertFriendsToProtoFriendInfo();
+    }
+
+
+    public async Task<List<FriendInfo>> convertFriendsToProtoFriendInfo()
+    {
+        List<FriendInfo> friend_infos = new();
+
+        foreach (var friend in m_friends)
+        {
+            FriendInfo info = new();
+            (var result, var friend_attibute) = getFriendAttribFromAttribute(friend.Value);
+            if (result.isFail())
+            {
+                continue;
+            }
+            NullReferenceCheckHelper.throwIfNull(friend_attibute, () => $"friend_attibute is null !!!");
+
+            info.Guid = friend_attibute.FriendGuid;
+            info.FolderName = friend_attibute.FolderName;
+            info.IsNew = friend_attibute.IsNew;
+            info.NickName = await getFriendNickname(friend_attibute.FriendGuid);
+
+            friend_infos.Add(info);
+        }
+        return friend_infos;
+    }
+
+    private async Task<string> getFriendNickname(string friendGuid)
+    {
+        var (result, attrib) = await NicknameDoc.findNicknameFromGuid(friendGuid);
+        if (result.isFail())
+        {
+            Log.getLogger().error($"User : {friendGuid} has not Exist NicknameDoc");
+
+            return "notexistnickname";
+        }
+        NullReferenceCheckHelper.throwIfNull(attrib, () => $"attrib is null !!!");
+
+        return attrib.Nickname;
+    }
+
+    private (Result, FriendAttribute?) getFriendAttribFromAttribute(Friend friend)
+    {
+        var result = new Result();
+
+        var attribute = friend.getEntityAttribute<FriendAttribute>();
+        if (attribute is null)
+        {
+            var err_msg = $"Fail to get FriendAttribute, owner : {getOwner().toBasicString()}";
+            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return (result, null);
+        }
+        return (result, attribute);
+    }
+
+    public async Task<(Result, FriendRequestCache?)> sendedRequestExistCheck(FriendReqCacheRequest cache, string friendGuid)
+    {
+        var result = new Result();
+
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var received_requests = await cache.getSendedFriendRequests();
+        var send_friend_action = owner.getEntityAction<SendFriendRequestAction>();
+        NullReferenceCheckHelper.throwIfNull(send_friend_action, () => $"send_friend_action is null !!! - {owner.toBasicString()}");
+
+        //내가 요청 보낸 정보가 없으면 리턴..
+        (var is_sended, var req_cache) = send_friend_action.isSendedRequest(received_requests, friendGuid);
+        if (false == is_sended)
+        {
+            string err_msg = $"requeat info not exist send guid : {owner.getUserGuid()}, friend_guid : {friendGuid}, {toBasicString()}";
+            result.setFail(ServerErrorCode.FriendRequestNotExistInfo, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return (result, null);
+        }
+
+        return (result, req_cache);
+    }
+
+    public async Task<(Result, FriendRequestCache?)> receivedRquestsExitstCheck(FriendReqCacheRequest cache, string friendGuid)
+    {
+        var result = new Result();
+
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var received_requests = await cache.getReceivedFriendRequests();
+        var send_friend_action = owner.getEntityAction<SendFriendRequestAction>();
+        NullReferenceCheckHelper.throwIfNull(send_friend_action, () => $"send_friend_action is null !!! - {owner.toBasicString()}");
+
+        //요청 받은 정보가 없으면 리턴..
+        //상대방이 먼저 취소한경우 여기에 해당
+        (var is_received, var req_cache) = send_friend_action.isReceivedRequest(received_requests, friendGuid);
+        if (false == is_received)
+        {
+            string err_msg = $"requeat info not exist receive guid : {owner.getUserGuid()}, friend_guid : {friendGuid}, {toBasicString()}";
+            result.setFail(ServerErrorCode.FriendRequestNotExistInfo, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return (result, null);
+        }
+
+        return (result, req_cache);
+    }
+
+    public Result friendMaxCountCheck()
+    {
+        var result = new Result();
+
+        if (MetaHelper.GameConfigMeta.MaxFriendsNum <= m_friends.Values.Count)
+        {
+            var err_msg = $"my friend count already max count owner : {getOwner().toBasicString()}, friendCount : {m_friends.Values.Count}";
+            result.setFail(ServerErrorCode.FriendInfoMyCountAlreadyMaxCount, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        return result;
+    }
+
+    public Result raiseErrorIfExistFriend(string friendGuid)
+    {
+        var result = new Result();
+
+        if (m_friends.ContainsKey(friendGuid))
+        {
+            var err_msg = $"already exist friend : {friendGuid}, friendGuids : {JsonConvert.SerializeObject(m_friends.Keys)}, owner : {getOwner().toBasicString()}";
+            result.setFail(ServerErrorCode.FriendRequestAlreadyFriend, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        return result;
+    }
+
+    public bool isFriend(string friendGuid)
+    {
+        return m_friends.ContainsKey(friendGuid);
+    }
+
+    public ConcurrentDictionary<string, Friend> getFriends() => m_friends;
+
+    public FriendAttribute? getFriendAttribute(string friendGuid)
+    {
+        if (!m_friends.TryGetValue(friendGuid, out var friend))
+            return null;
+
+        var friend_attribute = friend.getEntityAttribute<FriendAttribute>();
+        return friend_attribute;
+    }
+
+    public Friend? getFriend(string friendGuid)
+    {
+        m_friends.TryGetValue(friendGuid, out var friend);
+        return friend;
+    }
+
+    public static FriendErrorMember makeFriendMemberError(ServerErrorCode errorCode, string guid)
+    {
+        FriendErrorMember errormember = new();
+        errormember.ErrorCode = errorCode;
+        errormember.Guid = guid;
+        return errormember;
+    }
+
+    public void deleteFriend(string friendGuid)
+    {
+        m_friends.TryRemove(friendGuid, out _);
+    }
+}

GameServer/Contents/Friend/Action/FriendFolderAction.cs

@@ -0,0 +1,472 @@
+using Amazon.S3.Model;
+using Newtonsoft.Json;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+
+namespace GameServer
+{
+    public enum FriendFolderorderType
+    {
+        ALPHABETICAL = 1,
+        STATEFUL = 2,
+    }
+    public class FriendFolderAction : EntityActionBase
+    {
+        public FriendFolderAction(Player owner)
+            : base(owner)
+        {
+        }
+
+        public override async Task<Result> onInit()
+        {
+            var result = new Result();
+            return await Task.FromResult(result);
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public async Task<Result> loadFriendFolder()
+        {
+            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 DBQFriendFoldersReadAll(owner.getUserGuid()));
+            }
+            var result = await QueryHelper.sendQueryAndBusinessLog(batch);
+            return result;
+        }
+
+        public ServerCommon.FriendFolder? getFriendFolder(string folderName)
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var friend_folder_attribute = player.getEntityAttribute<FriendFolderAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_folder_attribute, () => $"friend_folder_attribute is null !!!");
+
+            friend_folder_attribute.m_folders.TryGetValue(folderName, out var folder);
+            return folder;
+        }
+
+        public Result addFriendFolder(string folderName)
+        {
+            var friend_folder_attribute = getFriendFolderAttribute();
+            
+            var result = raiseErrorIfExistFolder(friend_folder_attribute, folderName);
+            if (result.isFail()) return result;
+
+            result = maxFolderNameLengthCheck(folderName);
+            if (result.isFail()) return result;
+
+            result = folderCountCheck(friend_folder_attribute);
+            if (result.isFail()) return result;
+
+            var folder = makeFriendFolder(folderName);
+            if (false == friend_folder_attribute.m_folders.TryAdd(folderName, folder))
+            { 
+                var err_msg = $"folderInfo.Folders.TryAdd Error folderName : {folderName}, folder : {JsonConvert.SerializeObject(folder)}";
+                result.setFail(ServerErrorCode.FolderCreateFail, err_msg);
+                Log.getLogger().error(err_msg);
+            }
+            friend_folder_attribute.modifiedEntityAttribute();
+            return result;
+        }
+
+        public Result holdFriendFolder(string folderName)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var friend_folder_attribute = owner.getEntityAttribute<FriendFolderAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_folder_attribute, () => $"friend_folder_attribute is null !!!");
+
+            var result = raiseErrorIfNotExistFolder(friend_folder_attribute, folderName);
+            if (result.isFail()) return result;
+
+            result = folderHoldCountCheck(friend_folder_attribute);
+            if (result.isFail()) return result;
+
+            result = holdFriendFolder(friend_folder_attribute, folderName);
+            if (result.isFail()) return result;
+            
+            return result;
+        }
+        public Result releaseFriendFolder(string folderName)
+        {
+            var friend_folder_attribute = getFriendFolderAttribute();
+
+            var result = raiseErrorIfNotExistFolder(friend_folder_attribute, folderName);
+            if (result.isFail()) return result;
+
+            result = releaseFriendFolder(friend_folder_attribute, folderName);
+            if (result.isFail()) return result;
+
+            return result;
+        }
+
+        public Result changeFriendFolderLocation(string myGuid, string friendGuid, string folderName)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var friend_folder_attribute = getFriendFolderAttribute();
+
+            var result = raiseErrorIfNotExistFolder(friend_folder_attribute, folderName);
+            if (result.isFail()) return result;
+            
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+            var friends = friend_agent_action.getFriends();
+            
+            friends.TryGetValue(friendGuid, out var friend);
+            NullReferenceCheckHelper.throwIfNull(friend, () => $"friend is null !!!");
+
+            var friend_attribute = friend.getEntityAttribute<FriendAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_attribute, () => $"friend_attribute is null !!!");
+
+            friend_attribute.modifiedEntityAttribute();
+
+            //폴더명이 동일하면 그냥 성공했다고 리턴 처리
+            if (true == friend_attribute.FolderName.Equals(folderName))
+            {
+                return result;
+            }
+            friend_attribute.FolderName = folderName;
+
+            return result;
+        }
+
+        public Result renameFriendFolderConditionCheck(string oldFolderName, string newFolderName)
+        {
+            var owner = getOwner();
+            
+            var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+            NullReferenceCheckHelper.throwIfNull(friend_folder_action, () => $"friend_folder_action is null !!!");
+
+            var folder_folder_attribute = friend_folder_action.getFriendFolderAttribute();
+
+            var result = raiseErrorIfNotExistFolder(folder_folder_attribute, oldFolderName);
+            if (result.isFail()) return result;
+
+            result = raiseErrorIfExistFolder(folder_folder_attribute, newFolderName);
+            if (result.isFail()) return result;
+
+            result = raiseErrorIfDefaultFolder(oldFolderName);
+            if (result.isFail()) return result;
+
+            result = maxFolderNameLengthCheck(newFolderName);
+            if (result.isFail()) return result;
+
+            return result;
+        }
+
+        public async Task<Result> renameFriendFolder(string userGuid, string oldFolderName, string newFolderName)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var folder = getFriendFolder(oldFolderName);
+            
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+            NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => $"friend_agent_action is null !!!");
+
+            var friends = friend_agent_action.getFriends();
+
+            //폴더명 수정
+            var friend_folder_Attribute = owner.getEntityAttribute<FriendFolderAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_folder_Attribute, () => $"friend_folder_Attribute is null !!!");
+
+            var result = new Result();
+            if (false == friend_folder_Attribute.m_folders.TryRemove(oldFolderName, out var folderValue))
+            {
+                var err_msg = $"friend_folder_attrib not exist folderName : {oldFolderName}, attrib : {JsonConvert.SerializeObject(friend_folder_Attribute)}";
+                result.setFail(ServerErrorCode.FolderNameNotExist, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+            ServerCommon.FriendFolder new_folder = copyFriendFolder(folderValue);
+            new_folder.FolderName = newFolderName;
+            friend_folder_Attribute.m_folders.TryAdd(newFolderName, new_folder);
+            friend_folder_Attribute.modifiedEntityAttribute();
+
+            List<FriendInterlockCacheRequest> caches = new();
+            //관련 친구 데이터 수정
+            foreach (var friend in friends)
+            {
+                var friend_attribbute = friend.Value.getEntityAttribute<FriendAttribute>();
+                NullReferenceCheckHelper.throwIfNull(friend_attribbute, () => $"friend_attribbute is null !!!");
+
+                if (friend_attribbute.FolderName.Equals(oldFolderName))
+                {
+                    IFriendInterlockAction action = new RenameFriendFolderInterlockAction(owner, userGuid, friend_attribbute, newFolderName);
+                    (result, var lock_cache) = await action.doInterLockAndGetCache();
+                    if (result.isFail())
+                    {
+                        //여기서 에러나도 수정 transaction 은 진행되야 되기 때문에 continue 처리
+                        Log.getLogger().error($"RenameFriendFolderInterlockAction error userGuid : /*owner.getUserGuid()트랜잭션안에서 이거 호출하면 안됨*/" +
+                            $" , friend_attribbute : {JsonConvert.SerializeObject(friend_attribbute)}, newFolderName : {newFolderName}");
+                        continue;
+                    }
+                    if (lock_cache != null)
+                    {
+                        caches.Add(lock_cache);
+                    }
+                }
+            }
+
+            var server_logic = GameServerApp.getServerLogic();
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.RenameFriendFolder, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+            }
+
+            result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+            foreach (var cache in caches)
+            {
+                await cache.removeFirstCache();
+            }
+            return result;
+        }
+
+        public async Task<Result> deleteFriendFolder(string myGuid, string folderName)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var friend_folder_attribute = getFriendFolderAttribute();
+
+            var result = raiseErrorIfDefaultFolder(folderName);
+            if (result.isFail()) return result;
+            
+            result = raiseErrorIfDefaultFolder(folderName);
+            if (result.isFail()) return result;
+            
+            // 삭제하려는 폴더가 없으면 그냥 성공 처리 
+            if (false == isFolderNameExist(friend_folder_attribute, folderName))
+            {
+                return new();
+            }
+
+            //폴더 삭제 처리
+            friend_folder_attribute.m_folders.TryRemove(folderName, out var folder);
+            friend_folder_attribute.modifiedEntityAttribute();
+
+            //db 업데이트 처리
+            //폴더 삭제 처리,  친구 리스트 돌면서 폴더명 기본으로 바꿔주기
+            var server_logic = GameServerApp.getServerLogic();
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+            NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => $"friend_agent_action is null !!!");
+
+            var friends = friend_agent_action.getFriends();
+            foreach (var friend in friends)
+            {
+                var friend_attribute = friend.Value.getEntityAttribute<FriendAttribute>();
+                NullReferenceCheckHelper.throwIfNull(friend_attribute, () => $"friend_attribute is null !!!");
+
+                if (friend_attribute.FolderName.Equals(folderName))
+                {
+                    IFriendInterlockAction interlock_action = new DeleteFriendFolderInterlockAction(owner, myGuid, friend_attribute);
+                    result = await interlock_action.doInterlockAction();
+                    if (result.isFail()) return result;
+
+                    friend_attribute.modifiedEntityAttribute();
+                }
+            }
+            return result;
+        }
+
+        private ServerCommon.FriendFolder makeFriendFolder(string folderName)
+        {
+            ServerCommon.FriendFolder folder = new ServerCommon.FriendFolder();
+            folder.FolderName = folderName;
+            DateTime dt = DateTimeHelper.Current;
+            folder.CreateTime = dt;
+            folder.HoldTime = dt;
+            folder.IsHold = 0;
+
+            return folder;
+        }
+
+        private ServerCommon.FriendFolder copyFriendFolder(ServerCommon.FriendFolder folder)
+        {
+            ServerCommon.FriendFolder new_folder = new ServerCommon.FriendFolder();
+            new_folder.FolderName = folder.FolderName;
+            new_folder.CreateTime = folder.CreateTime;
+            new_folder.HoldTime = folder.HoldTime;
+            new_folder.IsHold = folder.IsHold;
+
+            return new_folder;
+        }
+
+        private Result holdFriendFolder(FriendFolderAttribute friendFolderAttribute, string folderName)
+        {
+            var result = new Result();
+
+            if (false == friendFolderAttribute.m_folders.TryGetValue(folderName, out var folder))
+            {
+                string err_msg = $"friend_folder_attrib tryGet Error folderName : {folderName}, attrib : {JsonConvert.SerializeObject(friendFolderAttribute)}";
+                result.setFail(ServerErrorCode.ServerLogicError, err_msg);
+                Log.getLogger().error(err_msg);
+                return result;
+            }
+            folder.IsHold = 1;
+            friendFolderAttribute.modifiedEntityAttribute();
+            return result;
+        }
+
+        private Result releaseFriendFolder(FriendFolderAttribute friend_folder_attribute, string folderName)
+        {
+            var result = new Result();
+
+            if (false == friend_folder_attribute.m_folders.TryGetValue(folderName, out var folder))
+            {
+                string err_msg = $"friend_folder_attrib tryGet Error folderName : {folderName}, folderAttrib :  {JsonConvert.SerializeObject(friend_folder_attribute)} ";
+                result.setFail(ServerErrorCode.ServerLogicError, err_msg);
+                Log.getLogger().error(err_msg);
+                return result;
+            }
+            folder.IsHold = 0;
+            friend_folder_attribute.modifiedEntityAttribute();
+            return result;
+        }
+
+        public Result changeOrderType(Int32 orderType)
+        {
+            var result = new Result();
+
+            switch (orderType)
+            {
+                case (Int32)FriendFolderorderType.ALPHABETICAL:
+                case (Int32)FriendFolderorderType.STATEFUL:
+                    break;
+                default:
+
+                    var err_msg = $"FolderOdertypeInvalid OrderType = {orderType}";
+                    result.setFail(ServerErrorCode.FolderOdertypeInvalid, err_msg);
+                    Log.getLogger().error(err_msg);
+
+                    return result;
+            }
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var friend_folder_attribute = owner.getEntityAttribute<FriendFolderAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_folder_attribute, () => $"friend_folder_attribute is null !!!");
+
+            friend_folder_attribute.m_folder_order_type = (short)orderType;
+            friend_folder_attribute.modifiedEntityAttribute();
+            return result;
+        }
+        
+
+        public FriendFolderAttribute getFriendFolderAttribute()
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var attribute =  owner.getEntityAttribute<FriendFolderAttribute>();
+            NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
+
+            return attribute;
+        }
+
+        private Result raiseErrorIfExistFolder(FriendFolderAttribute friendFolderAttribute, string folderName)
+        {
+            var result = new Result();
+
+            if (true == isFolderNameExist(friendFolderAttribute, folderName))
+            {
+                var err_msg = $"{folderName} is already exist  but origin folders : {JsonConvert.SerializeObject(friendFolderAttribute)}";
+                result.set(ServerErrorCode.FolderNameAlreadyExist, err_msg);
+                Log.getLogger().error(err_msg);
+                return result;
+            }
+            return result;
+        }
+
+        private Result raiseErrorIfNotExistFolder(FriendFolderAttribute friendFolderAttribute, string folderName)
+        {
+            var result = new Result();
+            if (false == isFolderNameExist(friendFolderAttribute, folderName))
+            {
+                var err_msg = $"recved folderName is {folderName} but origin folders : {JsonConvert.SerializeObject(friendFolderAttribute)}";
+                result.set(ServerErrorCode.FolderNameNotExist, err_msg);
+                Log.getLogger().error(err_msg);
+                return result;
+            }
+            return result;
+        }
+
+        private bool isFolderNameExist(FriendFolderAttribute friendFolderAttribute, string makeFolderName)
+        {
+            return friendFolderAttribute.m_folders.ContainsKey(makeFolderName);
+        }
+
+        private Result raiseErrorIfDefaultFolder(string folderName)
+        {
+            var result = new Result();
+            if (folderName.Equals(ServerCommon.Constant.FRIEND_FOLDER_DEFUALT_NAME))
+            {
+                result.set(ServerErrorCode.FolderReNameCannotDefault, $"folderName is {folderName}");
+                return result;
+            }
+            return result;
+        }
+
+        private Result maxFolderNameLengthCheck(string folderName)
+        {
+            var result = new Result();
+            if (folderName.Length > MetaHelper.GameConfigMeta.FriendFolderNameMaxLength)
+            {
+                result.set(ServerErrorCode.FolderNameExceededLength, $"folderName is {folderName}");
+                return result;
+            }
+            return result;
+        }
+
+
+        private Result folderCountCheck(FriendFolderAttribute friendFolderAttribute)
+        {
+            var result = new Result();
+
+            if (friendFolderAttribute.m_folders.Count >= MetaHelper.GameConfigMeta.FriendFolderMaxCount)
+            {
+                var err_msg = $"folderInfo.Folders.Count is {friendFolderAttribute.m_folders.Count}, Server Max Count = {MetaHelper.GameConfigMeta.FriendFolderMaxCount}";
+                result.set(ServerErrorCode.FolderCountExceed, err_msg);
+                Log.getLogger().error(err_msg);
+                return result;
+            }
+
+            return result;
+        }
+
+        private Result folderHoldCountCheck(FriendFolderAttribute friendFolderAttribue)
+        {
+            var result = new Result();
+            int holdCount = 0;
+            
+            foreach (var folder in friendFolderAttribue.m_folders.Values)
+            {
+                if (folder.IsHold == 1) holdCount++;
+            }
+
+            if (holdCount >= MetaHelper.GameConfigMeta.FriendFolderMaxHoldCount)
+            {
+                var err_msg = $"folderInfo.Folders.Hold_Count is {holdCount}, Server Max  Hold Count = {MetaHelper.GameConfigMeta.FriendFolderMaxHoldCount}";
+                result.set(ServerErrorCode.FolderNameAlreadyMaxHoldCount, err_msg);
+                Log.getLogger().error(err_msg);
+                return result;
+            }
+
+            return result;
+        }
+    }
+}

GameServer/Contents/Friend/Action/FriendInviteMyhomeAction.cs

@@ -0,0 +1,291 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+
+using Google.Protobuf.WellKnownTypes;
+using Newtonsoft.Json;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+using static ServerMessage.Types;
+
+
+namespace GameServer;
+
+public class MyhomeInviteInfo
+{
+    public string SenderId { get; set; }
+    public string SenderGuid { get; set; }
+    public string SenderNickName { get; set; }
+    public DateTime ExpireTime { get; set; }
+    public DateTime ReplyExpireTime { get; set; }
+
+    public string UniqueKey { get; set; }
+    public int ReplyValue { get; set; } = 0;
+    public IndunLocation MyhomeLocation { get; set; } = new();
+
+
+    public MyhomeInviteInfo(string senderId, string senderGuid, string senderNickname, IndunLocation location, DateTime expireTime, DateTime replyExpireTime, string uniqueKey)
+    {
+        SenderId = senderId;
+        SenderGuid = senderGuid;
+        SenderNickName = senderNickname;
+        MyhomeLocation = location;
+        ExpireTime = expireTime;
+        ReplyExpireTime = replyExpireTime;
+        ReplyValue = 0;
+        UniqueKey = uniqueKey;
+    }
+
+    public override string ToString()
+    {
+        return JsonConvert.SerializeObject(this);
+    }
+}
+
+public class FriendInviteMyhomeAction : EntityActionBase
+{
+    public FriendInviteMyhomeAction(Player owner)
+        : base(owner)
+    {
+    }
+
+    public override async Task<Result> onInit()
+    {
+        var result = new Result();
+        return await Task.FromResult(result);
+    }
+
+    public override void onClear()
+    {
+        return;
+    }
+
+    public async Task<(Result, List<FriendErrorMember>, List<ReceiveInviteMyHomeNoti>) > inviteFriendToMyhome(List<FriendNickNameInfo> infos)
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var location_attribute = owner.getEntityAttribute<LocationAttribute>();
+        NullReferenceCheckHelper.throwIfNull(location_attribute, () => $"location_attribute is null !!!");
+
+        var myhome_location = location_attribute.CurrentIndunLocation;
+        var instance_meta_Id = myhome_location.InstanceMetaId;
+
+        var result = isCurrentLocationMyHome(instance_meta_Id);
+        if (result.isFail()){ return (result, new(), new()); }
+
+        DateTime now = DateTime.UtcNow;
+        string unique_key = now.ToString();
+        var expire_time = now.AddMilliseconds(MetaHelper.GameConfigMeta.FriendIntiveCoolTime * 1000);
+        var reply_expire_time = now.AddMilliseconds(MetaHelper.GameConfigMeta.FriendInviteReplyTime * 1000);
+
+        MyhomeInviteInfo invite_info = new MyhomeInviteInfo(owner.getAccountId(), owner.getUserGuid(), owner.getUserNickname(), myhome_location, expire_time, reply_expire_time, unique_key);
+
+        List<FriendErrorMember> fail_infos = new();
+        List<FriendNickNameInfo> cond_check_success_infos = new();
+        foreach (var info in infos)
+        {
+            var cond_result = await conditionCheck(info);
+
+            if (cond_result.isFail())
+            {
+                var fail = FriendAgentAction.makeFriendMemberError(cond_result.getErrorCode(), info.TargetGuid);
+                fail_infos.Add(fail);
+            }
+            else
+            {
+                cond_check_success_infos.Add(info);
+            }
+        }
+
+        List<FriendNickNameInfo> cache_check_success_infos = new();
+        foreach (var info in cond_check_success_infos)
+        {
+            var cache_cond_result = await checkFriendsInviteCache(info, now);
+            if (cache_cond_result.isFail())
+            {
+                var fail = FriendAgentAction.makeFriendMemberError(cache_cond_result.getErrorCode(), info.TargetGuid);
+                fail_infos.Add(fail);
+            }
+            else
+            {
+                cache_check_success_infos.Add(info);
+            }
+        }
+
+
+        List<ReceiveInviteMyHomeNoti> success_guids = new();
+        foreach (var info in cache_check_success_infos)
+        {
+            var add_result = await addFriendsInviteCache(info, invite_info);
+            if (add_result.isFail())
+            {
+                var fail = FriendAgentAction.makeFriendMemberError(add_result.getErrorCode(), info.TargetGuid);
+                fail_infos.Add(fail);
+            }
+            else
+            {
+                ReceiveInviteMyHomeNoti notiInfo = makeInviteMyhomeNoti(owner, info.TargetGuid, info.TargetNickName, invite_info);
+                success_guids.Add(notiInfo);
+            }
+        }
+
+        
+
+        return (result, fail_infos, success_guids);
+    }
+
+    private ReceiveInviteMyHomeNoti makeInviteMyhomeNoti(Player owner, string targetGuid, string targetNickname, MyhomeInviteInfo inviteInfo)
+    {
+        
+        ReceiveInviteMyHomeNoti info = new();
+        info.InviterMyHomeId = inviteInfo.MyhomeLocation.InstanceRoomId;
+        info.ExpireTime = Timestamp.FromDateTime(inviteInfo.ExpireTime);
+        info.ReplyExpireTime = Timestamp.FromDateTime(inviteInfo.ReplyExpireTime);
+        info.UniqueKey = inviteInfo.UniqueKey;
+        info.BaseInfo = new();
+        info.BaseInfo.ReceiverGuid = targetGuid;
+        info.BaseInfo.ReceiverNickName = targetNickname;
+        info.BaseInfo.ReceiverId = string.Empty;//내가 초대하려는 유저의 아이디. 
+        info.BaseInfo.SenderGuid = inviteInfo.SenderGuid;
+        info.BaseInfo.SenderNickName = inviteInfo.SenderNickName;
+        info.BaseInfo.SenderId = owner.getAccountId(); //내 아이디
+
+        return info;
+    }
+        
+    private async Task<Result> addFriendsInviteCache(FriendNickNameInfo info, MyhomeInviteInfo inviteInfo)
+    {
+        var result = new Result();
+        var server_logic = GameServerApp.getServerLogic();
+        CharacterStorage characterStorage = new CharacterStorage();
+        characterStorage.Init(server_logic.getRedisDb(), string.Empty);
+
+        ServerErrorCode error_code = await characterStorage.AddReceivedInviteInfo(info.TargetGuid, inviteInfo.ToString());
+        if (error_code != ServerErrorCode.Success)
+        { 
+            result.setFail(error_code);
+            return result;
+        }
+        return result;
+    }
+
+    private async Task<Result> checkFriendsInviteCache(FriendNickNameInfo info, DateTime now)
+    {
+        var result = new Result();
+        
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        CharacterStorage characterStorage = new CharacterStorage();
+        characterStorage.Init(server_logic.getRedisDb(), string.Empty);
+        
+        //내가 초대 하려고 하는 유저가 받은 초대 정보
+        var invited_infos = await characterStorage.GetReceivedInviteInfo(info.TargetGuid);
+        if (invited_infos.Count > 0)
+        {
+            foreach (var invited_info in invited_infos)
+            {
+                var data = JsonConvert.DeserializeObject<MyhomeInviteInfo>(invited_info);
+                if (data is null) continue;
+
+                //data 가 기본적으로 만료시간을 전부 지나면 삭제 처리
+                if (now > data.ExpireTime)
+                {
+                    characterStorage.RemoveReceivedInviteInfo(info.TargetGuid, invited_info);
+                    continue;
+                }
+
+                //내가 보낸 정보가 남아있는 상태에서 보낸 시간이 아직 안지났으면 에러 처리
+                if (data.SenderGuid.Equals(owner.getUserGuid()) && now <= data.ExpireTime)
+                {
+                    result.setFail(ServerErrorCode.FriendInviteExpireTimeRemain);
+                    break;
+                }
+
+                //내가 보낸 정보가 아닌 데이터인데 수락해야되는 시간이 남아 있는경우 
+                if (!data.SenderGuid.Equals(owner.getUserGuid()) && now <= data.ReplyExpireTime)
+                {
+                    //수락 시간이 남아 있는데 거절한 상태가 아니면 
+                    if (data.ReplyValue == (int)InviteFriendReplyType.Refuse) continue;
+                    result.setFail(ServerErrorCode.FriendInviteWaitingOtherInvite);
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    private async Task<Result> conditionCheck(FriendNickNameInfo info)
+    {
+        string target_guid = info.TargetGuid;
+
+        var player = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var login_cache_request = new LoginCacheOtherUserRequest(player, server_logic.getRedisConnector(), target_guid);
+        var result = await login_cache_request.fetchLogin();
+
+        var friend_cache = login_cache_request.getLoginCache();
+        if (result.isFail())
+        {
+            var err_msg = $"friend Login Cache error : target_guid - {target_guid}";
+            result.setFail(ServerErrorCode.TargetUserNotLogIn, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+        if (friend_cache is null)
+        {
+            result.setFail(ServerErrorCode.FriendInfoOffline);
+            return result;
+        }
+
+        if (friend_cache.State == PlayerStateType.DontDistrub)
+        {
+            result.setFail(ServerErrorCode.FriendInviteDontDisturbState);
+            return result;
+        }
+
+        if (friend_cache.InstanceRoomId.Contains(ServerCommon.Constant.PREFIX_MYHOME_INSTANCE_ROOM_ID))
+        {
+            var err_msg = $"friend another myhome : friend_guid - {target_guid}, my_guid - {player.getUserGuid()}, currentRommonIntanceId - {friend_cache.InstanceRoomId}";
+            result.setFail(ServerErrorCode.FriendIsInAnotherMyhome, err_msg);
+            //Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        return result;
+    }
+
+    public Result isCurrentLocationMyHome(Int32 instancMetaId)
+    {
+        var result = new Result();
+        
+        if (!MetaData.Instance._IndunTable.TryGetValue(instancMetaId, out var indun_data))
+        {
+            string err_msg = $"Not Found IndunData. instanceMetaId:{instancMetaId}";
+            result.setFail(ServerErrorCode.NotExistInstanceRoom, err_msg);
+            Log.getLogger().error(err_msg);
+            return result;
+
+        }
+        if (indun_data.ContentsType != ContentsType.MyHome)
+        {
+            string err_msg = $"my pos is not myhome InstanceRoom  owner : {getOwner().toBasicString()}, intance_room : {instancMetaId}";
+            result.setFail(ServerErrorCode.FriendInviteMyPosIsNotMyHome, err_msg);
+            Log.getLogger().error(err_msg);
+            return result;
+        }
+        return result;
+    }
+}

GameServer/Contents/Friend/Action/FriendReplyInviteMyhomeAction.cs

@@ -0,0 +1,244 @@
+using GameServer.Contents.Room;
+using Google.Protobuf.WellKnownTypes;
+using Grpc.Core;
+using Nettention.Proud;
+using Newtonsoft.Json;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata.Ecma335;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class FriendReplyInviteMyhomeRefference
+    {
+        public FriendReplyInviteMyhomeRefference(Int32 replyValue)
+        {
+            m_reply_datetime = DateTimeHelper.Current;
+            m_reply_value = replyValue;
+        }
+        public Int32 m_reply_value { get; set; } = 0;
+        public DateTime m_reply_datetime { get; set; } = DateTimeHelper.Current;
+        public LoginCacheOtherUserRequest? m_invitor_login_cache_nullable { get; set; } = null;
+        
+        public string m_invitor_guid { get; set; } = string.Empty;
+        //public bool m_is_replyable { get; set; } = false; //지금 응답 가능한 상태인에대한 bool 값 true가 되어야 응답이 가능한상태
+        public string m_accepted_invite_info { get; set; } = string.Empty; //수락한 초대 정보
+        public CharacterStorage? m_storage_nullable { get; set; } = null;
+        
+        //private string m_otp = string.Empty;
+        //private string m_friend_myhome_server_address = string.Empty;
+        //private Int32 m_friend_myhome_server_port = 0;
+        public ServerConnectInfo? m_server_connect_info_nullable { get; set; } = null;
+    }
+
+    public class FriendReplyInviteMyhomeAction : EntityActionBase
+    {
+
+        public FriendReplyInviteMyhomeAction(EntityBase owner)
+            : base(owner)
+        { }
+
+
+        public override Task<Result> onInit()
+        {
+            var result = new Result();
+            return Task.FromResult(result);
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+        
+
+        public Result acceptReply(FriendReplyInviteMyhomeRefference replyRef)
+        {
+            var result = new Result();
+
+            result = removeInviteInfo(replyRef);
+            if (result.isFail()) return result;
+
+            return result;
+        }
+
+
+        public async Task<Result> checkReplyableAboutInvite(string roomId, string invitorId, FriendReplyInviteMyhomeRefference reply_ref)
+        {
+            var result = new Result();
+
+            //초대한 유저가 온라인인지 체크
+            (result, var invitor_login_cache) = await invitorOnlineCheck(invitorId);
+            if (result.isFail()) return result;
+            
+            reply_ref.m_invitor_login_cache_nullable = invitor_login_cache;
+            NullReferenceCheckHelper.throwIfNull(reply_ref.m_invitor_login_cache_nullable, () => $"reply_ref.m_invitor_login_cache_nullable is null !!!");
+
+            var login_cache = reply_ref.m_invitor_login_cache_nullable.getLoginCache();
+            NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null !!!");
+
+            reply_ref.m_invitor_guid = login_cache.UserGuid;
+            reply_ref.m_storage_nullable = getStorage();
+
+            //나를 초대한 모든 정보 가져오기
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var all_received_invites = await reply_ref.m_storage_nullable.GetReceivedInviteInfo(owner.getUserGuid());
+
+            result = await replyableCheck(all_received_invites, reply_ref);
+            if (result.isFail()) return result;
+
+            return result;
+        }
+
+        private CharacterStorage getStorage()
+        {
+            var server_logic = GameServerApp.getServerLogic();
+            CharacterStorage storage = new CharacterStorage();
+            storage.Init(server_logic.getRedisDb(), string.Empty);
+
+            return storage;
+        }
+
+        private async Task<Result> replyableCheck(List<string> receivedInvites, FriendReplyInviteMyhomeRefference reply_ref)
+        {
+            var result = new Result();
+            
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            bool is_replyable = false;
+
+            foreach (var received_invite in receivedInvites)
+            {
+                var origin_data = JsonConvert.DeserializeObject<MyhomeInviteInfo>(received_invite);
+                if (origin_data is null) continue;
+                var update_data = JsonConvert.DeserializeObject<MyhomeInviteInfo>(received_invite);
+                if (update_data is null) continue;
+
+                //data 가 기본적으로 만료시간을 전부 지나면 삭제 처리
+                if (reply_ref.m_reply_datetime > origin_data.ExpireTime)
+                {
+                    NullReferenceCheckHelper.throwIfNull(reply_ref.m_storage_nullable, () => $"reply_ref.m_storage_nullable is null !!!");
+
+                    reply_ref.m_storage_nullable.RemoveReceivedInviteInfo(owner.getUserGuid(), received_invite);
+                    continue;
+                }
+
+                //내가 받은 정보가 아닌 데이터인데 수락해야되는 시간이 남아 있는경우 정상 로직이므로 true처리
+                if (origin_data.SenderGuid.Equals(reply_ref.m_invitor_guid) && reply_ref.m_reply_datetime <= origin_data.ReplyExpireTime)
+                {
+                    is_replyable = true;
+                    if (reply_ref.m_reply_value == (int)InviteFriendReplyType.Refuse)
+                    {
+                        //거절인경우 정보 업데이트 해줘야된다. 
+                        update_data.ReplyValue = (int)InviteFriendReplyType.Refuse;
+
+                        NullReferenceCheckHelper.throwIfNull(reply_ref.m_storage_nullable, () => $"reply_ref.m_storage_nullable is null !!!");
+
+                        await reply_ref.m_storage_nullable.UpdateReceivedInviteInfo(owner.getUserGuid(), origin_data.ToString(), update_data.ToString());
+                    }
+                    else if (reply_ref.m_reply_value == (int)InviteFriendReplyType.DontDisturb)
+                    {
+                        //방해 금지인 경우만 삭제 처리 해준다. 
+                        NullReferenceCheckHelper.throwIfNull(reply_ref.m_storage_nullable, () => $"reply_ref.m_storage_nullable is null !!!");
+
+                        reply_ref.m_storage_nullable.RemoveReceivedInviteInfo(owner.getUserGuid(), received_invite);
+                    }
+                    else if (reply_ref.m_reply_value == (int)InviteFriendReplyType.Accept)
+                    {
+                        reply_ref.m_accepted_invite_info = received_invite;
+                    }
+                    break;
+                }
+            }
+
+            if (false == is_replyable)
+            { 
+                result.setFail(ServerErrorCode.FriendInviteAlreadyExpire);
+                return result;
+            }
+
+
+            return result;
+        }
+
+        private async Task<(Result, LoginCacheOtherUserRequest?)> invitorOnlineCheck(string invitorId)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+
+            (var result, var account_doc) = await AccountBaseDoc.findUserGuidFromAccountId(invitorId);
+            if(result.isFail())
+            {
+                return (result, null);
+            }
+            NullReferenceCheckHelper.throwIfNull(account_doc, () => $"ownaccount_docer is null !!!");
+
+            var account_attrib = account_doc.getAttrib<AccountBaseAttrib>();
+            NullReferenceCheckHelper.throwIfNull(account_attrib, () => $"account_attrib is null !!!");
+
+            var invitor_guid = account_attrib.UserGuid;
+
+            var login_cache_request = new LoginCacheOtherUserRequest(owner, server_logic.getRedisConnector(), invitor_guid);
+            await login_cache_request.fetchLogin();
+            if (login_cache_request is null)
+            {
+                var info_msg = $"login_cache_request is null, invitorId : {invitorId}, invitor_guid : {invitor_guid}";
+                result.setFail(ServerErrorCode.FriendInfoOffline, info_msg);
+                Log.getLogger().info(result.toBasicString());
+                return (result, null);
+            }
+
+            return (result, login_cache_request);
+        }
+
+
+        public Result removeInviteInfo(FriendReplyInviteMyhomeRefference replyRef)
+        {
+            var result = new Result();
+            
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            NullReferenceCheckHelper.throwIfNull(replyRef.m_storage_nullable, () => $"replyRef.m_storage_nullable is null !!!");
+
+            replyRef.m_storage_nullable.RemoveReceivedInviteInfo(owner.getUserGuid(), replyRef.m_accepted_invite_info);
+            return result;
+        }
+
+
+        public async Task<Result> joinFriendMyhomeFromInvite(string roomId, FriendReplyInviteMyhomeRefference replyRef)
+        {
+            await Task.Delay(3000);
+
+            var result = new Result();
+            var err_msg = string.Empty;
+
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var game_zone_move_action = owner.getEntityAction<GameZoneMoveAction>();
+            (result, var server_connection_info) = await game_zone_move_action.tryJoinFriendMyhomeInstance(roomId);
+            if (result.isFail())
+            {
+                err_msg = $"Failed to tryJoinFriendMyhomeInstance() !!! : {result.toBasicString()}";
+                Log.getLogger().error(err_msg);
+
+                return result;
+            }
+
+            replyRef.m_server_connect_info_nullable = server_connection_info;
+
+            return result;
+        }
+    }
+}

GameServer/Contents/Friend/Action/KickFriendsFromMyHomeAction.cs

@@ -0,0 +1,146 @@
+using Nettention.Proud;
+using OtpNet;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static ClientToLoginMessage.Types;
+
+namespace GameServer
+{
+    public class KickFriendsFromMyHomeAction : EntityActionBase
+    {
+        public KickFriendsFromMyHomeAction(EntityBase owner) 
+            : base(owner)
+        {
+        }
+
+        public override Task<Result> onInit()
+        {
+            var result = new Result();
+            return Task.FromResult(result);
+        }
+
+        public override void onClear()
+        {
+            
+            return;
+        }
+
+        public async Task<Result> setKickableFriendsInfo(KickFriendResult kickFriendResult)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => "Player is null !!!");
+
+            var location_attribute = owner.getEntityAttribute<LocationAttribute>();
+            NullReferenceCheckHelper.throwIfNull(location_attribute, () => $"LocationAttribute is null !!! - player:{owner.toBasicString()}");
+
+            var myhome_action = owner.getEntityAction<FriendInviteMyhomeAction>();
+            NullReferenceCheckHelper.throwIfNull(myhome_action, () => $"FriendInviteMyhomeAction is null !!! - player:{owner.toBasicString()}");
+
+            var myhome_location = location_attribute.CurrentIndunLocation;
+            var instance_room_Id = myhome_location.InstanceRoomId;
+            var instance_meta_Id = myhome_location.InstanceMetaId;
+
+            var result = myhome_action.isCurrentLocationMyHome(instance_meta_Id);
+            if (result.isFail()) return result;
+            
+
+            InstanceRoomStorage room_storage = new InstanceRoomStorage();
+            room_storage.Init(GameServerApp.getServerLogic().getRedisDb(), string.Empty);
+
+            InstanceRoomInfo? instance_room = await room_storage.GetInstanceRoomInfo(instance_room_Id);
+            if (instance_room == null)
+            {
+                string err_msg = $"{owner.getAccountId()} Not found InstanceRoomInfo. InstanceRoomId:{instance_room_Id}";
+                result.setFail(ServerErrorCode.NotExistInstanceRoom, err_msg);
+                return result;
+            }
+
+            List<string> room_members = await room_storage.GetInstanceRoomMemberList(instance_room.roomId);
+            foreach (string member in room_members)
+            {
+                if (member.Equals(owner.getAccountId())) continue;
+                kickFriendResult.getNeedNotiMembers().Add(member);
+            }
+            
+            if (kickFriendResult.getNeedNotiMembers().Count == 0)
+            {
+                string err_msg = $"Room member count is zero. InstanceRoomId:{instance_room_Id}";
+                result.setFail(ServerErrorCode.FriendKickMemberNotExist, err_msg);
+                return result;
+            }
+            return result;
+        }
+
+
+        public async Task<Result> sendKickNoti(KickFriendResult kickFriendResult)
+        {
+            //noti 보내야한다. 
+            await Task.Delay(3000);
+
+
+            var result = new Result();
+
+            var server_logic = GameServerApp.getServerLogic();
+            var plyaer_manager = server_logic.getPlayerManager();
+
+            foreach (var member in kickFriendResult.getNeedNotiMembers())
+            {
+                
+                if(false == plyaer_manager.tryGetUserByPrimaryKey(member, out var player))
+                {
+                    string err_msg = $"Not found player. member:{member}";
+                    Log.getLogger().warn(err_msg);
+                    continue;
+                }
+                
+                //noti 전송
+                send_GS2C_NTF_SERVER_INFO_BY_FRIEND_KICKED_NOTI(player);
+
+            }
+            return result;
+        }
+        private bool send_GS2C_NTF_SERVER_INFO_BY_FRIEND_KICKED_NOTI(Player player)
+        {
+            ClientToGame msg = new ClientToGame();
+            msg.Message = new ClientToGameMessage();
+            msg.Message.ServerInfoByFriendKickedNoti = new();
+            msg.Message.ServerInfoByFriendKickedNoti.ServerInfo = new ServerConnectInfo
+            {
+                ServerAddr = string.Empty,
+                ServerPort = 0,
+                Otp = string.Empty
+            };
+            if (false == GameServerApp.getServerLogic().onSendPacket(player, msg)) return false;
+            return true;
+        }
+
+        public void kickFriendsFromMyHome()
+        {
+            string err_msg = $"need code implement !!!!";
+            Log.getLogger().error(err_msg);
+        }
+    }
+
+    public class KickFriendResult
+    {
+        List<string> m_need_noti_members = new();
+        List<FriendErrorMember> m_error_member = new();
+
+        public List<FriendErrorMember> getErrorMembers()
+        {
+            return m_error_member;
+        }
+
+        public List<string> getNeedNotiMembers()
+        {
+            return m_need_noti_members;
+        }
+
+    }
+}

GameServer/Contents/Friend/Action/ReplyReceivedFriendRequestAction.cs

@@ -0,0 +1,114 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class ReplyReceivedFriendRequestAction : EntityActionBase
+{
+    public ReplyReceivedFriendRequestAction(Player owner) 
+        : base(owner)
+    {
+    }
+
+    public override async Task<Result> onInit()
+    {
+        var result = new Result();
+        return await Task.FromResult(result);
+    }
+
+    public override void onClear()
+    {
+        return;
+    }
+    public async Task<Result> replyReceivedFriendRequest(string myGuid, string targetGuid, int replyType)
+    {
+        var result = new Result();
+
+        switch (replyType)
+        {
+            case (int)FriendRequestReplyType.Accept:
+                result = await addFriend(myGuid, targetGuid);
+                if (result.isFail())
+                {
+                    Log.getLogger().error("replyReceivedFriendRequest addFriend error");
+                    return result;
+                }
+                    
+                break;
+            case (int)FriendRequestReplyType.Refuse:
+                result = await refuseFriend(myGuid, targetGuid);
+                if (result.isFail())
+                {
+                    Log.getLogger().error("replyReceivedFriendRequest refuseFriend error");
+                    return result;
+                }
+                break;
+        }
+
+        return result;
+    }
+
+
+
+    private async Task<Result> addFriend(string myGuid, string friendGuid)
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var friend_agent_action = owner.getEntityAction<FriendAgentAction>();            
+
+        var result = friend_agent_action.friendMaxCountCheck();
+        if (result.isFail()) return result;
+
+        result = friend_agent_action.raiseErrorIfExistFriend(friendGuid);
+        if (result.isFail()) return result;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var friend_request_cache = new FriendReqCacheRequest(owner, myGuid, friendGuid, server_logic.getRedisConnector());
+
+        //요청이 존재하는지 체크하면서 해당 요청 가져온다.            
+        (result, var req) = await friend_agent_action.receivedRquestsExitstCheck(friend_request_cache, friendGuid);
+        if (result.isFail() || req is null) return result;
+
+        //요청 만료시간이 지나버린경우
+        DateTime now = DateTimeHelper.Current;
+        var expire_time = req.m_request_time.AddSeconds(MetaHelper.GameConfigMeta.SentFriendRequestValidTime);
+        if (now > expire_time)
+        {
+            var err_msg = $"friendRequestList expired targetGuid = {friendGuid}, m_request_time = {req.m_request_time}, expire_time : {expire_time}, now : {now}, {owner.toBasicString()}";
+            result.setFail(ServerErrorCode.AddFriendAlreadyExpired, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        result = await friend_request_cache.deleteFriendByReply();
+
+
+        if (result.isFail()) return result;
+
+
+        return result;
+
+    }
+    
+
+    private async Task<Result> refuseFriend(string myGuidm, string friendGuid)
+    {
+        var owner = getOwner() as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var server_logic = GameServerApp.getServerLogic();
+        
+        FriendReqCacheRequest cache = new FriendReqCacheRequest(owner, myGuidm, friendGuid, server_logic.getRedisConnector());
+        var result = await cache.refuseFriendRequest();
+
+        return result;
+    }
+    
+}

GameServer/Contents/Friend/Action/SendFriendRequestAction.cs

@@ -0,0 +1,127 @@
+using Google.Protobuf.WellKnownTypes;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+
+namespace GameServer
+{
+    //친구 요청에 관한 것만 여기 모은다. 
+
+    public class SendFriendRequestAction : EntityActionBase
+    {
+        public SendFriendRequestAction(Player owner)
+            : base(owner)
+        {
+        }
+
+        public override async Task<Result> onInit()
+        {
+            var result = new Result();
+            return await Task.FromResult(result);
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public async Task<Result> addRequestToCache(string nickname, string friendGuid)
+        {
+            var result = new Result();
+
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+            var my_guid = owner.getUserGuid();
+
+            //나한테 요청 보낼 수 없다. 
+            if (friendGuid.Equals(my_guid))
+            {
+                var err_msg = $"Can't Send To Self myGuid = {my_guid} targetGuid : {friendGuid}, {toBasicString()}";
+                result.setFail(ServerErrorCode.FriendRequestCantSendToSelf, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+            
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+
+            //이미 친구인 경우
+            result = friend_agent_action.raiseErrorIfExistFriend(friendGuid);
+            if(result.isFail()) return result;
+
+
+            //친구 맥스 초과
+            result = friend_agent_action.friendMaxCountCheck();
+            if (result.isFail()) return result;
+
+            //'내가 차단한 유저라 보낼수 없다' 
+            var block_action = owner.getEntityAction<BlockUserAgentAction>();
+            if (true == block_action.isBlockUser(friendGuid))
+            {
+                var err_msg = $"Can't Send To Block User myGuid = {my_guid} targetGuid : {friendGuid}, {toBasicString()}";
+                result.setFail(ServerErrorCode.FriendRequestCannotSendBlockUser, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+
+            var server_logic = GameServerApp.getServerLogic();
+            var friend_request_cache = new FriendReqCacheRequest(owner, my_guid, friendGuid, server_logic.getRedisConnector());
+
+            //이미 요청 보냈다
+            var sended_reqs = await friend_request_cache.getSendedFriendRequests();
+            (var is_sended, var req) = isSendedRequest(sended_reqs, friendGuid);
+            if (true == is_sended)
+            {
+                //이미 요청 보낸것이므로 예외 처리
+                string err_msg = $"requeat friend already send guid : {my_guid}, friend_guid : {friendGuid}, {toBasicString()}";
+                result.setFail(ServerErrorCode.FriendRequestAlreadySend, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+
+            //이미 요청 받았다
+            var received_reqs = await friend_request_cache.getReceivedFriendRequests();
+            (var is_received, var _) = isReceivedRequest(received_reqs, friendGuid);
+            if (true == is_received)
+            {
+                //이미 요청 받은것이므로 예외 처리
+                string err_msg = $"requeat friend already receive guid : {my_guid}, friend_guid : {friendGuid}, {toBasicString()}";
+                result.setFail(ServerErrorCode.FriendRequestAlreadyReceive, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+
+            //lock
+            DateTime now = DateTime.UtcNow;
+            IFriendInterlockAction interlock_action = new SendFriendRequestInterlockAction(owner, owner.getUserGuid(), friendGuid, now);
+            result = await interlock_action.doInterlockAction();
+            if(result.isFail()) return result;
+
+            return result;
+        }
+
+
+        public (bool, FriendRequestCache?) isSendedRequest(List<FriendRequestCache> sended_reqs, string friendGuid)
+        {
+            foreach (var req in sended_reqs)
+            {
+                if (req.m_receiver_guid.Equals(friendGuid))
+                {
+                    return (true, req);
+                }
+            }
+            return (false, null);
+        }
+
+        public (bool, FriendRequestCache?) isReceivedRequest(List<FriendRequestCache> received_reqs, string friendGuid)
+        {
+            foreach (var req in received_reqs)
+            {
+                if (req.m_sender_guid.Equals(friendGuid))
+                {
+                    return (true, req);
+                }
+            }
+            return (false, null);
+        }
+    }
+}

GameServer/Contents/Friend/DbQuery/DBQAddFriend.cs

@@ -0,0 +1,180 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class DBQAddFriend : QueryExecutorBase
+{
+    private string m_my_combination_key_for_pk = string.Empty;
+    private string m_my_combination_key_for_sk = string.Empty;
+    private string m_friend_combination_key_for_pk = string.Empty;
+    private string m_friend_combination_key_for_sk = string.Empty;
+
+    private FriendDoc m_my_doc = new();
+    private string m_my_pk = string.Empty;
+    private FriendDoc m_friend_doc = new();
+    private string m_friend_pk = string.Empty;
+
+    private string m_my_guid = string.Empty;
+    private string m_friend_guid = string.Empty;
+
+    public DBQAddFriend(string myGuid, string friendGuid) 
+        : base(typeof(DBQAddFriend).Name)
+    {
+        m_my_combination_key_for_pk = myGuid;
+        m_my_combination_key_for_sk = friendGuid;
+        m_friend_combination_key_for_pk = friendGuid;
+        m_friend_combination_key_for_sk = myGuid;
+        m_my_guid = myGuid;
+        m_friend_guid = friendGuid;
+    }
+
+    //===================================================================================================
+    // DB 쿼리 직전에 준비해야 할 로직들을 작성한다.
+    //===================================================================================================
+
+    public override Task<Result> onPrepareQuery()
+    {
+        var result = new Result();
+
+        var player = getOwner();
+        NullReferenceCheckHelper.throwIfNull(player, () => "player is null !!!");
+
+        DateTime now = DateTimeHelper.Current;
+
+        m_my_doc = new FriendDoc();
+        m_friend_doc = new FriendDoc();
+        
+        var my_attrib = m_my_doc.getAttrib<FriendAttrib>();
+        NullReferenceCheckHelper.throwIfNull(my_attrib, () => "my_attrib is null !!!");
+
+        my_attrib.FriendGuid = m_friend_combination_key_for_pk;
+        my_attrib.CreateTime = now;
+        my_attrib.FolderName = ServerCommon.Constant.FRIEND_FOLDER_DEFUALT_NAME;
+        my_attrib.IsNew = 1;
+
+        var friend_attrib = m_friend_doc.getAttrib<FriendAttrib>();
+        NullReferenceCheckHelper.throwIfNull(friend_attrib, () => "friend_attrib is null !!!");
+
+        friend_attrib.FriendGuid = m_my_combination_key_for_pk;
+        friend_attrib.CreateTime = now;
+        friend_attrib.FolderName = ServerCommon.Constant.FRIEND_FOLDER_DEFUALT_NAME;
+        friend_attrib.IsNew = 1;
+
+        m_my_doc.setCombinationKeyForPKSK(m_my_combination_key_for_pk, m_my_combination_key_for_sk);
+        m_friend_doc.setCombinationKeyForPKSK(m_friend_combination_key_for_pk, m_friend_combination_key_for_sk);
+
+        var my_error_code = m_my_doc.onApplyPKSK();
+        var friend_error_code = m_friend_doc.onApplyPKSK();
+        if (my_error_code.isFail() || friend_error_code.isFail())
+        {
+            var err_msg = $"Failed to onApplyPKSK() !!! my_error_code : {my_error_code.toBasicString()},  friend_error_code : {friend_error_code.toBasicString()} - {player.toBasicString()}";
+            result.setFail(my_error_code, err_msg);
+            Log.getLogger().error(err_msg);
+            return Task.FromResult(result);
+        }
+
+        m_my_pk = m_my_doc.getPK();
+        m_friend_pk = m_friend_doc.getPK();
+
+        return Task.FromResult(result);
+    }
+
+    //===================================================================================================
+    // onPrepareQuery()를 성공할 경우 호출된다.
+    //===================================================================================================
+    public override async Task<Result> onQuery()
+    {
+        var result = new Result();
+
+        var player = getOwner();
+        NullReferenceCheckHelper.throwIfNull(player, () => "player is null !!!");
+
+        var query_batch = getQueryBatch();
+        NullReferenceCheckHelper.throwIfNull(query_batch, () => $"query_batch is null !!! - {player.toBasicString()}");
+
+        var db_connector = query_batch.getDynamoDbConnector();
+
+        (result, var my_document) = await m_my_doc.onCopyToDocument();
+        if(result.isFail())
+        {
+            var err_msg = $"Failed to onCopyToDocument() !!! : {result.toBasicString()}, m_my_pk:{m_my_pk}, m_friend_pk:{m_friend_pk} - {toBasicString()}, {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return result;
+        }
+
+        (result,  var friend_document) = await m_friend_doc.onCopyToDocument();
+        if (result.isFail())
+        {
+            var err_msg = $"Failed to onCopyToDocument() !!! : {result.toBasicString()}, m_my_pk:{m_my_pk}, m_friend_pk:{m_friend_pk} - {toBasicString()}, {player.toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return result;
+        }
+
+        var table = db_connector.getTableByDoc(m_friend_doc);
+        var my_docmument_ctx = new DynamoDbDocumentQueryContext(table.TableName, my_document, QueryType.Upsert);
+        var my_friend_ctx = new DynamoDbDocumentQueryContext(table.TableName, friend_document, QueryType.Upsert);
+
+        (result, _) = await table.simpleTransactWriteWithDocument(new List<DynamoDbDocumentQueryContext>() { my_docmument_ctx, my_friend_ctx }, 2, query_batch.getTransId());
+        if (result.isFail())
+        {
+            var err_msg = $"Failed to simpleTransactWrite !!! m_my_pk = {m_my_pk}, m_friend_pk = {m_friend_pk} - {toBasicString()}, {player.toBasicString()}";
+            result.setFail(ServerErrorCode.DynamoDbTransactException, err_msg);
+            Log.getLogger().error(err_msg);
+
+            return result;
+        }
+        
+        return result;
+    }
+
+    //===================================================================================================
+    // DB 쿼리를 성공하고, doFnCommit()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+    //===================================================================================================
+    public override Task onQueryResponseCommit()
+    {
+        //여기서 메모리 업데이트
+        var owner = getOwner();
+        NullReferenceCheckHelper.throwIfNull(owner, () => "owner is null !!!");
+
+        var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => "friend_agent_action is null !!!");
+
+        var friends = friend_agent_action.getFriends();
+
+        Friend friend = new(owner);
+        var new_friend_attribue = friend.getEntityAttribute<FriendAttribute>();
+        NullReferenceCheckHelper.throwIfNull(new_friend_attribue, () => "new_friend_attribue is null !!!");
+
+        var friend_attrib = m_friend_doc.getAttrib<FriendAttrib>();
+        NullReferenceCheckHelper.throwIfNull(friend_attrib, () => "friend_attrib is null !!!");
+
+        new_friend_attribue.UserGuid = m_my_guid;
+        new_friend_attribue.FriendGuid = m_friend_guid;
+        new_friend_attribue.CreateTime = friend_attrib.CreateTime;
+        new_friend_attribue.FolderName = friend_attrib.FolderName;
+        new_friend_attribue.IsNew = friend_attrib.IsNew;
+
+        friends.TryAdd(m_friend_guid, friend);
+        return Task.CompletedTask;
+    }
+
+
+    //===================================================================================================
+    // DB 쿼리를 실패하고, doFnRollback()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+    //===================================================================================================
+    public override Task onQueryResponseRollback(Result errorResult)
+    {
+        return Task.CompletedTask;
+    }
+
+    private new Player? getOwner() => getQueryBatch()?.getLogActor() as Player;
+}

GameServer/Contents/Friend/DbQuery/DBQDeleteFriend.cs

@@ -0,0 +1,141 @@
+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 DBQDeleteFriend : QueryExecutorBase
+{
+    private string m_my_combination_key_for_pk = string.Empty;
+    private string m_my_combination_key_for_sk = string.Empty;
+    private string m_friend_combination_key_for_pk = string.Empty;
+    private string m_friend_combination_key_for_sk = string.Empty;
+
+    private FriendDoc m_my_doc = new();
+    private string m_my_pk = string.Empty;
+    private FriendDoc m_friend_doc = new();
+    private string m_friend_pk = string.Empty;
+
+
+    public DBQDeleteFriend(string myGuid, string friendGuid)
+        : base(typeof(DBQDeleteFriend).Name)
+    {
+        m_my_combination_key_for_pk = myGuid;
+        m_my_combination_key_for_sk = friendGuid;
+        m_friend_combination_key_for_pk = friendGuid;
+        m_friend_combination_key_for_sk = myGuid;
+    }
+
+    
+    //===================================================================================================
+    // DB 쿼리 직전에 준비해야 할 로직들을 작성한다.
+    //===================================================================================================
+    public override Task<Result> onPrepareQuery()
+    {
+        var result = new Result();
+
+        var owner = getOwner();
+        NullReferenceCheckHelper.throwIfNull(owner, () => "owner is null !!!");
+
+        m_my_doc = new FriendDoc();
+        m_friend_doc = new FriendDoc();
+
+        m_my_doc.setCombinationKeyForPKSK(m_my_combination_key_for_pk, m_my_combination_key_for_sk);
+        m_friend_doc.setCombinationKeyForPKSK(m_friend_combination_key_for_pk, m_friend_combination_key_for_sk);
+
+        var my_error_code = m_my_doc.onApplyPKSK();
+        var friend_error_code = m_friend_doc.onApplyPKSK();
+        if (my_error_code.isFail() || friend_error_code.isFail())
+        {
+            var err_msg = $"Failed to onApplyPKSK() !!! my_error_code : {my_error_code.toBasicString()},  friend_error_code : {friend_error_code.toBasicString()} - {owner.toBasicString()}";
+            result.setFail(my_error_code, err_msg);
+            Log.getLogger().error(err_msg);
+            return Task.FromResult(result);
+        }
+
+        m_my_pk = m_my_doc.getPK();
+        m_friend_pk = m_friend_doc.getPK();
+
+        return Task.FromResult(result);
+    }
+
+    //===================================================================================================
+    // onPrepareQuery()를 성공할 경우 호출된다.
+    //===================================================================================================
+    public override async Task<Result> onQuery()
+    {
+        var result = new Result();
+
+        var query_batch = getQueryBatch();
+        NullReferenceCheckHelper.throwIfNull(query_batch, () => "query_batch is null !!!");
+
+        var db_connector = query_batch.getDynamoDbConnector();
+
+        (result, var my_document) = await m_my_doc.onCopyToDocument();
+        if (result.isFail())
+        {
+            var err_msg = $"Failed to onCopyToDocument() !!! : {result.toBasicString()}, m_my_pk:{m_my_pk}, m_friend_pk:{m_friend_pk} - {toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return result;
+        }
+
+        (result, var friend_document) = await m_friend_doc.onCopyToDocument();
+        if (result.isFail())
+        {
+            var err_msg = $"Failed to onCopyToDocument() !!! : {result.toBasicString()}, m_my_pk:{m_my_pk}, m_friend_pk:{m_friend_pk} - {toBasicString()}";
+            Log.getLogger().error(err_msg);
+            return result;
+        }
+
+        var table = db_connector.getTableByDoc(m_friend_doc);
+        var my_docmument_ctx = new DynamoDbDocumentQueryContext(table.TableName, my_document, QueryType.Delete);
+        var my_friend_ctx = new DynamoDbDocumentQueryContext(table.TableName, friend_document, QueryType.Delete);
+        (result, _) = await table.simpleTransactWriteWithDocument(new List<DynamoDbDocumentQueryContext>() { my_docmument_ctx, my_friend_ctx }, 2, query_batch.getTransId());
+        if (result.isFail())
+        {
+            var err_msg = $"Failed to simpleTransactWrite !!! : {result.toBasicString()}, m_my_pk:{m_my_pk}, m_friend_pk:{m_friend_pk} - {toBasicString()}";
+            Log.getLogger().error(err_msg);
+
+            return result;
+        }
+
+        return result;
+    }
+
+    //===================================================================================================
+    // DB 쿼리를 성공하고, doFnCommit()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+    //===================================================================================================
+    public override Task onQueryResponseCommit()
+    {
+        //여기서 메모리 업데이트
+        var owner = getOwner();
+        NullReferenceCheckHelper.throwIfNull(owner, () => "owner is null !!!");
+
+        var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => "friend_agent_action is null !!!");
+
+        var friends = friend_agent_action.getFriends();
+
+        if (false == friends.TryRemove(m_friend_combination_key_for_pk, out var friend))
+        { 
+            var err_msg = $"Delete Friend : Failed to TryRemove !!! m_my_combination_key_for_sk = {m_my_combination_key_for_sk}, m_friend_combination_key_for_sk = {m_friend_combination_key_for_sk} - {toBasicString()}";
+            Log.getLogger().error(err_msg);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    //===================================================================================================
+    // DB 쿼리를 실패하고, doFnRollback()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+    //===================================================================================================
+    public override Task onQueryResponseRollback(Result errorResult)
+    {
+        return Task.CompletedTask;
+    }
+
+    private new Player? getOwner() => getQueryBatch()?.getLogActor() as Player;
+}

GameServer/Contents/Friend/DbQuery/DBQFriendFoldersReadAll.cs

@@ -0,0 +1,110 @@
+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 DBQFriendFoldersReadAll : QueryExecutorBase
+    {
+        //prefix 문자열 뒤에 붙는 문자열을 의미
+        private string m_combination_key_for_pk = string.Empty;
+        private string m_pk = string.Empty;
+
+        private readonly List<DynamoDbDocBase> m_to_read_friend_folder_list_base_docs = new();
+
+        public DBQFriendFoldersReadAll(string combinationKeyForPK /*onwer_guid*/)
+            : base(typeof(DBQFriendFoldersReadAll).Name)
+        {
+            m_combination_key_for_pk = combinationKeyForPK;
+        }
+
+        //===================================================================================================
+        // DB 쿼리 직전에 준비해야 할 로직들을 작성한다.
+        //===================================================================================================
+        public override Task<Result> onPrepareQuery()
+        {
+            var result = new Result();
+
+            var owner = getOwner();
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var doc = new FriendFolderDoc(m_combination_key_for_pk);
+            var error_code = doc.onApplyPKSK();
+            if (error_code.isFail())
+            {
+                var err_msg = $"Failed to onApplyPKSK() !!! : {error_code.toBasicString()} - {owner.toBasicString()}";
+                result.setFail(error_code, err_msg);
+                Log.getLogger().error(err_msg);
+                return Task.FromResult(result);
+            }
+            
+            m_pk = doc.getPK();
+
+
+            return Task.FromResult(result);
+        }
+
+        //===================================================================================================
+        // onPrepareQuery()를 성공할 경우 호출된다.
+        //===================================================================================================
+        public override async Task<Result> onQuery()
+        {
+            var owner = getOwner();
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var query_batch = getQueryBatch();
+            NullReferenceCheckHelper.throwIfNull(query_batch, () => $"query_batch is null !!!");
+
+            var db_connector = query_batch.getDynamoDbConnector();
+            var query_config = db_connector.makeQueryConfigForReadByPKSK(m_pk);
+
+            (var result, var read_docs) = await db_connector.simpleQueryDocTypesWithQueryOperationConfig<FriendFolderDoc>(query_config, eventTid: query_batch.getTransId());
+            if (result.isFail())
+            {
+                var err_msg = $"FriendFolderDoc Reas Error !!! : - {toBasicString()}, {owner.toBasicString()}";
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+
+            m_to_read_friend_folder_list_base_docs.AddRange(read_docs);
+
+            //이건 select만 해오는 거니 그냥 여기서 셋팅 처리
+            var friend_folder_attribute = owner.getEntityAttribute<FriendFolderAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_folder_attribute, () => $"friend_folder_attribute is null !!!");
+
+            result = await ServerBase.DataCopyHelper.copyEntityAttributeFromDocs(friend_folder_attribute, m_to_read_friend_folder_list_base_docs);
+            if (result.isFail())
+            {
+                return result;
+            }
+
+            return result;
+        }
+
+
+        //===================================================================================================
+        // DB 쿼리를 성공하고, doFnCommit()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+        //===================================================================================================
+        public override Task onQueryResponseCommit()
+        {
+            Log.getLogger().debug("DBQFriendFoldersReadAll.onQueryResponseCommit() : " + toBasicString());
+            return Task.CompletedTask;
+        }
+
+
+        //===================================================================================================
+        // DB 쿼리를 실패하고, doFnRollback()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+        //===================================================================================================
+        public override Task onQueryResponseRollback(Result errorResult)
+        {
+            Log.getLogger().debug("DBQFriendFoldersReadAll.onQueryResponseRollback() : " + toBasicString());
+            return Task.CompletedTask;
+        }
+
+        public new Player? getOwner() => getQueryBatch()?.getLogActor() as Player;
+    }
+}

GameServer/Contents/Friend/DbQuery/DBQFriendsReadAll.cs

@@ -0,0 +1,103 @@
+using ServerCommon;
+using ServerCore; using ServerBase;
+
+namespace GameServer
+{
+    public class DBQFriendsReadAll : QueryExecutorBase
+    {
+        //prefix 문자열 뒤에 붙는 문자열을 의미
+        private string m_combination_key_for_pk = string.Empty;
+
+        private string m_pk = string.Empty;
+
+        private readonly List<FriendDoc> m_to_read_friends_docs = new();
+
+        public DBQFriendsReadAll(string combinationKeyForPK /*onwer_guid*/)
+            : base(typeof(DBQFriendsReadAll).Name)
+        {
+            m_combination_key_for_pk = combinationKeyForPK;
+        }
+
+        //===================================================================================================
+        // DB 쿼리 직전에 준비해야 할 로직들을 작성한다.
+        //===================================================================================================
+        public override Task<Result> onPrepareQuery()
+        {
+            var result = new Result();
+
+            var owner = getOwner();
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var doc = new FriendDoc();
+            doc.setCombinationKeyForPK(m_combination_key_for_pk);
+
+            var error_code = doc.onApplyPKSK();
+            if (error_code.isFail())
+            {
+                var err_msg = $"Failed to onApplyPKSK() !!! : {error_code.toBasicString()} - {toBasicString()}, {owner.toBasicString()}";
+                result.setFail(error_code, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return Task.FromResult(result);
+            }
+
+            m_pk = doc.getPK();
+
+            return Task.FromResult(result);
+        }
+
+        //===================================================================================================
+        // onPrepareQuery()를 성공할 경우 호출된다.
+        //===================================================================================================
+        public override async Task<Result> onQuery()
+        {
+            var owner = getOwner();
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var query_batch = getQueryBatch();
+            NullReferenceCheckHelper.throwIfNull(query_batch, () => $"query_batch is null !!!");
+
+            var db_connector = query_batch.getDynamoDbConnector();
+            var query_config = db_connector.makeQueryConfigForReadByPKOnly(m_pk);
+
+            (var result, var read_docs) = await db_connector.simpleQueryDocTypesWithQueryOperationConfig<FriendDoc>(query_config, eventTid: query_batch.getTransId());
+            if (result.isFail())
+            {
+                return await Task.FromResult(result);
+            }
+            m_to_read_friends_docs.AddRange(read_docs);
+
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+            NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => $"friend_agent_action is null !!!");
+
+            foreach (var read_doc in read_docs)
+            {
+                var set_result = await friend_agent_action.setFriendsFromDoc(read_doc);
+                if (set_result.isFail())
+                { 
+                    continue;
+                }
+            }
+
+            return result;
+        }
+
+
+        //===================================================================================================
+        // DB 쿼리를 성공하고, doFnCommit()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+        //===================================================================================================
+        public override Task onQueryResponseCommit()
+        {
+            return Task.CompletedTask;
+        }
+
+        //===================================================================================================
+        // DB 쿼리를 실패하고, doFnRollback()가 QueryResultType.NotCalledQueryFunc를 반환할 경우 호출된다.
+        //===================================================================================================
+        public override Task onQueryResponseRollback(Result errorResult)
+        {
+            return Task.CompletedTask;
+        }
+
+        private new Player? getOwner() => getQueryBatch()?.getLogActor() as Player;
+    }
+}

GameServer/Contents/Friend/Friend.cs

@@ -0,0 +1,48 @@
+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 Friend : EntityBase
+{
+    public Friend(EntityBase parent)
+        : base(EntityType.Friend, parent)
+    {
+        addEntityAttributes();
+    }
+
+    public override async Task<Result> onInit()
+    {
+        addEntityAttributes();
+        return await base.onInit();
+    }
+
+    private void addEntityAttributes()
+    {
+        var owner = getRootParent() as Player ;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var direct_parent = getDirectParent();
+        NullReferenceCheckHelper.throwIfNull(direct_parent, () => $"direct_parent is null !!! - {owner.toBasicString()}");
+
+        addEntityAttribute(new FriendAttribute(this, owner.getUserGuid(), direct_parent));
+        addEntityAction(new FriendAction(this));
+    }
+
+
+    public override string toBasicString()
+    {
+        return $"{this.getTypeName()} - {getRootParent().toBasicString()}";
+    }
+
+    public override string toSummaryString()
+    {
+        return $"{this.getTypeName()} - {getRootParent().toBasicString()}";
+    }
+
+}

GameServer/Contents/Friend/FriendCheat.cs

@@ -0,0 +1,17 @@
+using ServerCommon;
+using ServerCore; using ServerBase;
+
+namespace GameServer;
+
+[ChatCommandAttribute("friendkick", typeof(ChatCommandFriendKick), AuthAdminLevelType.Developer, AuthAdminLevelType.GmNormal, AuthAdminLevelType.GmSuper)]
+internal class ChatCommandFriendKick : ChatCommandBase
+{
+    public override async Task invoke(Player player, string token, string[] args)
+    {
+        await Task.CompletedTask;
+
+        var friend_kick_action = player.getEntityAction<KickFriendsFromMyHomeAction>();
+
+        friend_kick_action.kickFriendsFromMyHome();
+    }
+}

GameServer/Contents/Friend/Helper/FriendNotifyHelper.cs

@@ -0,0 +1,390 @@
+
+using System.Collections.Concurrent;
+
+
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public static class FriendNotifyHelper
+{
+    public static void send_S2C_NTF_FRIENDS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var ntf_packet = new ClientToGame();
+        ntf_packet.Message = new();
+        ntf_packet.Message.FriendListNoti = new();
+
+        var friend_agent_action = player.getEntityAction<FriendAgentAction>();
+        ConcurrentDictionary<string, Friend> friends = friend_agent_action.getFriends();
+
+        foreach (var saved_friend in friends.Values)
+        {
+            var saved_friend_attribute = saved_friend.getEntityAttribute<FriendAttribute>();
+            NullReferenceCheckHelper.throwIfNull(saved_friend_attribute, () => $"saved_friend_attribute is null");
+
+            FriendInfo info = new();
+            info.Guid = saved_friend_attribute.FriendGuid;
+            info.NickName = saved_friend_attribute.Nickname;
+            info.FolderName = saved_friend_attribute.FolderName;
+            info.IsNew = saved_friend_attribute.IsNew;
+            ntf_packet.Message.FriendListNoti.FriendList.Add(info);
+        }
+
+        server_logic.onSendPacket(player, ntf_packet);
+    }
+
+    //customUI 추가 되면 삭제 할 예정
+    public static void send_S2C_NTF_FRIEND_FOLDERS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var ntf_packet = new ClientToGame();
+        ntf_packet.Message = new();
+        ntf_packet.Message.FriendFolderListNoti = new();
+
+        var friend_folder_attribute = player.getEntityAttribute<FriendFolderAttribute>();
+        NullReferenceCheckHelper.throwIfNull(friend_folder_attribute, () => $"friend_folder_attribute is null");
+
+        ntf_packet.Message.FriendFolderListNoti.FolderOrderType = friend_folder_attribute.m_folder_order_type;
+
+        foreach (var folder in friend_folder_attribute.m_folders.Values)
+        {
+            FriendFolder friend_folder = new();
+            friend_folder.FolderName = folder.FolderName;
+            friend_folder.IsHold = folder.IsHold;
+            friend_folder.HoldTime = Timestamp.FromDateTime(folder.HoldTime);
+            friend_folder.CreateTime = Timestamp.FromDateTime(folder.CreateTime);
+
+            ntf_packet.Message.FriendFolderListNoti.FriendFolderList.Add(friend_folder);
+        }
+        
+        server_logic.onSendPacket(player, ntf_packet);
+    }
+
+    public static async Task send_S2C_NTF_SENDED_FRIEND_REQUESTS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var ntf_packet = new ClientToGame();
+        ntf_packet.Message = new();
+        ntf_packet.Message.SendedFriendRequestNoti = new();
+
+        FriendReqCacheRequest cache_request = new FriendReqCacheRequest(player, player.getUserGuid(), server_logic.getRedisConnector());
+        List<FriendRequestCache> caches = await cache_request.getSendedFriendRequests();
+        
+        var infos = await fillupFriendRequestInfos(caches);
+        ntf_packet.Message.SendedFriendRequestNoti.RequestList.AddRange(infos);
+
+        server_logic.onSendPacket(player, ntf_packet);
+    }
+
+    public static async Task send_S2C_NTF_RECEIVED_FRIEND_REQUESTS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var ntf_packet = new ClientToGame();
+        ntf_packet.Message = new();
+        ntf_packet.Message.ReceivedFriendRequestNoti = new();
+
+        FriendReqCacheRequest cache_request = new FriendReqCacheRequest(player, player.getUserGuid(), server_logic.getRedisConnector());
+        List<FriendRequestCache> caches = await cache_request.getReceivedFriendRequests();
+
+        var infos = await fillupFriendRequestInfos(caches);
+        ntf_packet.Message.ReceivedFriendRequestNoti.RequestList.AddRange(infos);
+
+        server_logic.onSendPacket(player, ntf_packet);
+
+    }
+
+    private static async Task<List<FriendRequestInfo>> fillupFriendRequestInfos(List<FriendRequestCache> caches)
+    {
+        List<FriendRequestInfo> infos = new();
+
+        foreach (var request_friend in caches)
+        {
+            FriendRequestInfo info = new();
+            info.Guid = request_friend.m_receiver_guid;
+
+            (var result, var nickname_attrib) = await NicknameDoc.findNicknameFromGuid(request_friend.m_receiver_guid);
+            if (result.isFail())
+            {
+                Log.getLogger().error($"{request_friend.m_receiver_guid} user not exitst Nickname");
+                info.NickName = string.Empty;
+            }
+            else
+            {
+                NullReferenceCheckHelper.throwIfNull(nickname_attrib, () => $"nickname_attrib is null");
+
+                info.NickName = nickname_attrib.Nickname;
+            }
+            info.IsNew = request_friend.m_is_new;
+            info.RequestTime = Timestamp.FromDateTime(request_friend.m_request_time);
+
+            infos.Add(info);
+        }
+
+        return infos;
+    }
+
+    public static async Task sendLoginNotiToFriend(this Player player, bool isFirstLogin)
+    {
+        if (isFirstLogin)
+        {
+            await player.send_GS2CS_NTF_LOGIN_TO_FRIENDS();
+        }
+        else 
+        {
+            await player.send_GS2CS_NTF_STATE_TO_FRIENDS();
+        }
+    }
+
+    public static async Task<Result> send_GS2CS_NTF_LOGIN_TO_FRIENDS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var friend_action = player.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null");
+
+        var friends = friend_action.getFriends();
+
+        var login_cache_request = new LoginCacheRequest(player, server_logic.getRedisConnector());
+        var result = await login_cache_request.fetchLogin();
+        if (result.isFail()) return result;
+        
+        var login_cache = login_cache_request.getLoginCache();
+        NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null");
+
+        var location_info = player.getUserLocationInfo();
+       
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null");
+
+        foreach (var friend in friends)
+        {
+            var friend_guid = friend.Key;
+            var friend_login_cache = await getFriendCache(player, friend_guid);
+            if (friend_login_cache == null) continue;
+            var target_server = friend_login_cache.CurrentServer;
+
+            var message = new ServerMessage();
+            message.LoginNotiToFriend = new();
+            message.LoginNotiToFriend.BaseInfo = new();
+            message.LoginNotiToFriend.BaseInfo.SenderId = player.getUserGuid();
+            message.LoginNotiToFriend.BaseInfo.SenderGuid = player.getUserGuid();
+            message.LoginNotiToFriend.BaseInfo.SenderNickName = player.getUserNickname();
+            message.LoginNotiToFriend.BaseInfo.SenderState = (Int32)login_cache.State;
+            message.LoginNotiToFriend.BaseInfo.SenderMapId = location_info.Id;
+            message.LoginNotiToFriend.LocationInfo = location_info;
+            message.LoginNotiToFriend.BaseInfo.ReceiverId = friend_guid;
+            message.LoginNotiToFriend.BaseInfo.ReceiverGuid = friend_guid;
+            message.LoginNotiToFriend.BaseInfo.ReceiverNickName = string.Empty;
+            rabbit_mq.SendMessage(target_server, message);
+        }
+
+        return result;
+    }
+
+    public static async Task send_GS2CS_NTF_LOGOUT_TO_FRIENDS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var friend_action = player.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null");
+
+        var friends = friend_action.getFriends();
+
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null");
+
+        foreach (var friend in friends)
+        {
+            var friend_guid = friend.Key;
+            var friend_login_cache = await getFriendCache(player, friend_guid);
+            if (friend_login_cache == null) continue;
+            var target_server = friend_login_cache.CurrentServer;
+
+            ServerMessage message = new ServerMessage();
+            message.LogoutNotiToFriend = new();
+            message.LogoutNotiToFriend.BaseInfo = new();
+            message.LogoutNotiToFriend.BaseInfo.SenderId = player.getUserGuid();
+            message.LogoutNotiToFriend.BaseInfo.SenderGuid = player.getUserGuid();
+            message.LogoutNotiToFriend.BaseInfo.SenderNickName = player.getUserNickname();
+            message.LogoutNotiToFriend.BaseInfo.SenderState = 0;
+            message.LogoutNotiToFriend.BaseInfo.SenderMapId = 0;
+            message.LogoutNotiToFriend.BaseInfo.ReceiverId = friend_guid;
+            message.LogoutNotiToFriend.BaseInfo.ReceiverGuid = friend_guid;
+            message.LogoutNotiToFriend.BaseInfo.ReceiverNickName = string.Empty;
+            rabbit_mq.SendMessage(target_server, message);
+        }
+    }
+
+    public static async Task send_GS2CS_NTF_STATE_TO_FRIENDS(this Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var friend_action = player.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null");
+
+        var friends = friend_action.getFriends();
+
+        var login_cache_request = new LoginCacheRequest(player, server_logic.getRedisConnector());
+        var result = await login_cache_request.fetchLogin();
+        if (result.isFail()) return;
+        
+        var login_cache = login_cache_request.getLoginCache();
+        NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null");
+
+        var location_info = player.getUserLocationInfo();
+
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null");
+
+        foreach (var friend in friends)
+        {
+            var friend_guid = friend.Key;
+            var friend_login_cache = await getFriendCache(player, friend_guid);
+            if (friend_login_cache == null) continue;
+            var target_server = friend_login_cache.CurrentServer;
+
+            ServerMessage stateNoti = new()
+            {
+                StateNotiToFriend = new()
+            };
+            stateNoti.StateNotiToFriend.BaseInfo = new();
+            stateNoti.StateNotiToFriend.BaseInfo.SenderId = player.getUserGuid();
+            stateNoti.StateNotiToFriend.BaseInfo.SenderGuid = player.getUserGuid(); 
+            stateNoti.StateNotiToFriend.BaseInfo.SenderNickName = player.getUserNickname();
+            stateNoti.StateNotiToFriend.BaseInfo.SenderState = (Int32)login_cache.State;
+            stateNoti.StateNotiToFriend.BaseInfo.SenderMapId = location_info.Id;
+            stateNoti.StateNotiToFriend.BaseInfo.ReceiverId = friend_guid;
+            stateNoti.StateNotiToFriend.BaseInfo.ReceiverGuid = friend_guid;
+            stateNoti.StateNotiToFriend.BaseInfo.ReceiverNickName = string.Empty;
+            stateNoti.StateNotiToFriend.LocationInfo = location_info;
+
+            rabbit_mq.SendMessage(target_server, stateNoti);
+        }
+    }
+
+    public static async Task send_GS2CS_NTF_STATE_TO_FRIEND(this Player player, string friendGuid)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var login_cache_request = new LoginCacheRequest(player, server_logic.getRedisConnector());
+        var result = await login_cache_request.fetchLogin();
+        if (result.isFail()) return;
+        
+        var login_cache = login_cache_request.getLoginCache();
+        NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null");
+
+        var location_info = player.getUserLocationInfo();
+
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null");
+
+        var friend_login_cache = await getFriendCache(player, friendGuid);
+        if (friend_login_cache == null) return;
+        var target_server = friend_login_cache.CurrentServer;
+
+        ServerMessage stateNoti = new()
+        {
+            StateNotiToFriend = new()
+        };
+        stateNoti.StateNotiToFriend.BaseInfo = new();
+        stateNoti.StateNotiToFriend.BaseInfo.SenderId = player.getUserGuid();
+        stateNoti.StateNotiToFriend.BaseInfo.SenderGuid = player.getUserGuid();
+        stateNoti.StateNotiToFriend.BaseInfo.SenderNickName = player.getUserNickname();
+        stateNoti.StateNotiToFriend.BaseInfo.SenderState = (Int32)login_cache.State;
+        stateNoti.StateNotiToFriend.BaseInfo.SenderMapId = location_info.Id;
+        stateNoti.StateNotiToFriend.BaseInfo.ReceiverId = friendGuid;
+        stateNoti.StateNotiToFriend.BaseInfo.ReceiverGuid = friendGuid;
+        stateNoti.StateNotiToFriend.BaseInfo.ReceiverNickName = string.Empty;
+        stateNoti.StateNotiToFriend.LocationInfo = location_info;
+
+        rabbit_mq.SendMessage(target_server, stateNoti);
+    }
+
+    public static async Task<LoginCache?> getFriendCache(Player player, string friend_guid)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        var friend_login_cache_request = new LoginCacheOtherUserRequest(player, server_logic.getRedisConnector(), friend_guid);
+
+        var result = await friend_login_cache_request.fetchLogin();
+        if (result.isFail()) return null;
+
+        var friend_login_cache = friend_login_cache_request.getLoginCache();
+        return friend_login_cache;
+    }
+
+    public static async Task send_NTF_TO_FRIEND_ABOUT_LEAVING_HOME(Player player)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        
+        var friend_action = player.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null");
+
+        var friends = friend_action.getFriends();
+        
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null");
+
+        foreach (var friend in friends)
+        {
+            var friend_guid = friend.Key;
+            var friend_login_cache = await getFriendCache(player, friend_guid);
+            if (friend_login_cache == null) continue;
+            var target_server = friend_login_cache.CurrentServer;
+
+            ServerMessage notiMessage = new ServerMessage();
+            notiMessage.NtfFriendLeavingHome = new();
+            notiMessage.NtfFriendLeavingHome.Guid = player.getUserGuid();
+            notiMessage.NtfFriendLeavingHome.NickName = player.getUserNickname();
+            notiMessage.NtfFriendLeavingHome.ReceiverId = friend_guid;
+            
+            rabbit_mq.SendMessage(target_server, notiMessage);
+        }
+    }
+
+    public static async Task send_GS2CS_NTF_FRIEND_LEAVE_MYHOME(this Player player)
+    {
+        var friend_action = player.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null");
+
+        var friends = friend_action.getFriends();
+
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbitMQ4Game = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbitMQ4Game, () => $"rabbitMQ4Game is null");
+
+        foreach (var friend in friends)
+        {
+            var friend_guid = friend.Key;
+            var friend_login_cache = await getFriendCache(player, friend_guid);
+            if (friend_login_cache == null) continue;
+            var target_server = friend_login_cache.CurrentServer;
+
+            ServerMessage ntf_packet = new()
+            {
+                NtfFriendLeavingHome = new()
+            };
+            ntf_packet.NtfFriendLeavingHome.Guid = player.getUserGuid();
+            ntf_packet.NtfFriendLeavingHome.NickName = player.getUserNickname();
+            ntf_packet.NtfFriendLeavingHome.ReceiverId = friend_guid;
+
+            rabbitMQ4Game.SendMessage(target_server, ntf_packet);
+        };
+
+    }
+
+}

GameServer/Contents/Friend/LockAction/CancleFriendInterlockAction.cs

@@ -0,0 +1,44 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+
+public class CancelFriendRequestInterlockAction : FriendInterlockBase
+{
+    public CancelFriendRequestInterlockAction(UserBase owner, string myGuid, string friendGuid) : base(owner, myGuid, friendGuid)
+    {
+    }
+
+    public override async Task<Result> doAction()
+    {
+        var owner = getOwner();
+
+        var server_logic = GameServerApp.getServerLogic();
+        FriendReqCacheRequest cache = new FriendReqCacheRequest(owner, getMyGuid(), getFriendGuid(), server_logic.getRedisConnector());
+        var result = await cache.cancelFriendRequest();
+        if (result.isFail()) return result;
+        
+        //log
+        var invokers = new List<ILogInvoker>();
+        invokers.Add(new CancelFriendRequestBusinessLog(getMyGuid(), getFriendGuid()));
+        var log_action = new LogActionEx(LogActionType.CancelFriendRequest);
+        BusinessLogger.collectLogs(log_action, owner, invokers);
+
+
+
+
+        return result;
+    }
+
+    
+}

GameServer/Contents/Friend/LockAction/ChangeFriendFolderLocationInterlockAction.cs

@@ -0,0 +1,57 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+
+public class ChangeFriendFolderLocationInterlockAction : FriendInterlockBase
+{
+    private string m_folder_name;
+
+    public ChangeFriendFolderLocationInterlockAction(UserBase owner, string myGuid, string friendGuid, string folderName) : base(owner, myGuid, friendGuid)
+    {
+        m_folder_name = folderName;
+    }
+
+
+    public override async Task<Result> doAction()
+    {
+        var owner = getOwner();
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "ChangeFriendFolderLocation", delegateChangeFriendFolderLocation);
+        if (result.isFail()) return result;
+
+        return result;
+
+        async Task<Result> delegateChangeFriendFolderLocation() => await changeFriendFolderLocation(owner);
+
+    }
+
+    private async Task<Result> changeFriendFolderLocation(Player owner)
+    {
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        var result = friend_folder_action.changeFriendFolderLocation(getMyGuid(), getFriendGuid(), m_folder_name);
+        var server_logic = GameServerApp.getServerLogic();
+        if (result.isFail()) return result;
+
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+        if (result.isFail()) return result;
+
+
+        return result;
+    }
+}

GameServer/Contents/Friend/LockAction/ConfirmNewFriendInterlockAction.cs

@@ -0,0 +1,62 @@
+using Google.Protobuf.WellKnownTypes;
+using Nettention.Proud;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class ConfirmNewFriendInterlockAction : FriendInterlockBase
+    {
+        
+        public ConfirmNewFriendInterlockAction(UserBase owner, string myGuid, string friendGuid) : base(owner, myGuid, friendGuid)
+        {
+
+        }
+
+        public override async Task<Result> doAction()
+        {
+            var owner = getOwner();
+            var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "ConfirmNewFriend", delegateConfirmNewFriend);
+            return result;
+
+            async Task<Result> delegateConfirmNewFriend() => await confirmNewFriend(owner, getMyGuid(), getFriendGuid());
+        }
+
+        private async Task<Result> confirmNewFriend(Player owner, string myGuid, string guid)
+        {
+
+            var server_logic = GameServerApp.getServerLogic();
+
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+
+            if(myGuid.Equals(guid))
+            {
+                return new();
+            }
+            var owner_friend = friend_agent_action.getFriend(guid);
+            if(owner_friend == null)
+            {
+                return new();
+            }
+
+            var friend_attribute = owner_friend.getEntityAttribute<FriendAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_attribute, () => $"friend_attribute is null !!!");
+            friend_attribute.IsNew = 0;
+            friend_attribute.modifiedEntityAttribute();
+
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+            }
+            var result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+            return result;
+        }
+    }
+}

GameServer/Contents/Friend/LockAction/ConfirmNewReceivedFriendRequestInterlockAction.cs

@@ -0,0 +1,37 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class ConfirmNewReceivedFriendRequestInterlockAction : FriendInterlockBase
+{
+    public ConfirmNewReceivedFriendRequestInterlockAction(UserBase owner, string myGuid, string friendGuid) : base(owner, myGuid, friendGuid)
+    {
+
+    }
+    public override async Task<Result> doAction()
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        var owner = getOwner();
+
+        FriendReqCacheRequest friend_req_cache = new FriendReqCacheRequest(owner, getMyGuid(), getFriendGuid(), server_logic.getRedisConnector());
+        
+        var result = await friend_req_cache.confirmReceivedFriendRequest();
+        if(result.isFail())
+        {
+            Log.getLogger().error($"confirmReceivedFriendRequest error getMyGuid() : {getMyGuid()}, getFriendGuid() : {getFriendGuid()}");
+            return result;
+        }
+
+        return result;
+    }
+}

GameServer/Contents/Friend/LockAction/DeleteFriendFolderInterlockAction.cs

@@ -0,0 +1,28 @@
+using Google.Protobuf.WellKnownTypes;
+using ServerCommon;
+using ServerCommon.Cache;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class DeleteFriendFolderInterlockAction : FriendInterlockBase
+    {
+        private FriendAttribute m_friend_attrib;
+        public DeleteFriendFolderInterlockAction(UserBase owner, string myGuid, FriendAttribute friendAttib) : base(owner, myGuid, friendAttib.FriendGuid)
+        {
+            m_friend_attrib = friendAttib;
+        }
+
+        public override Task<Result> doAction()
+        {
+            var result = new Result();
+            m_friend_attrib.FolderName = ServerCommon.Constant.FRIEND_FOLDER_DEFUALT_NAME;
+
+            return Task.FromResult(result);
+        }
+    }
+}

GameServer/Contents/Friend/LockAction/DeleteFriendInterlockAction.cs

@@ -0,0 +1,50 @@
+using Google.Protobuf.WellKnownTypes;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class DeleteFriendInterlockAction : FriendInterlockBase
+    {
+        public DeleteFriendInterlockAction(UserBase owner, string myGuid, string deleteGuid) : base(owner, myGuid ,deleteGuid)
+        {
+
+        }
+
+        public override async Task<Result> doAction()
+        {
+            var result = new Result();
+
+            var server_logic = GameServerApp.getServerLogic();
+            var owner = getOwner();
+
+            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+            NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => $"friend_agent_action is null !!! - {owner.toBasicString()}");
+
+            var friend_attribute = friend_agent_action.getFriendAttribute(getFriendGuid());
+            NullReferenceCheckHelper.throwIfNull(friend_attribute, () => $"friend_attribute is null !!! - {owner.toBasicString()}");
+
+            friend_attribute.deleteEntityAttribute();
+
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.FriendDelete, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQDeleteFriend(getMyGuid(), getFriendGuid()));
+            }
+            var log_invoker = new DeleteFriendBusinessLog(getMyGuid(), getFriendGuid());
+            batch.appendBusinessLog(log_invoker);
+
+            result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+            return result;
+
+        }
+
+        
+    }
+}

GameServer/Contents/Friend/LockAction/FriendInterlockBase.cs

@@ -0,0 +1,79 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public interface IFriendInterlockAction
+{
+    public Task<Result> doInterlockAction();
+    public Task<(Result, FriendInterlockCacheRequest?)> doInterLockAndGetCache();
+}
+
+public abstract class FriendInterlockBase : IFriendInterlockAction
+{
+    private UserBase m_owner;
+    private string m_my_guid;
+    private string m_friend_guid;
+
+    public FriendInterlockBase(UserBase owner, string myGuid, string friendGuid)
+    {
+        m_owner = owner;
+        m_my_guid = myGuid;
+        m_friend_guid = friendGuid;
+    }
+
+    public abstract Task<Result> doAction();
+
+    public async Task<(Result, FriendInterlockCacheRequest?)> doInterLockAndGetCache()
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var friend_cache_request = new FriendInterlockCacheRequest(m_owner, server_logic.getRedisConnector(), m_my_guid, m_friend_guid);
+        var result = await friend_cache_request.getLock();
+        if (result.isFail()) return (result, null);
+
+        result = await doAction();
+        if (result.isFail()) return (result, null);
+
+        return (result, friend_cache_request);
+    }
+
+    public async Task<Result> doInterlockAction()
+    {
+        var server_logic = GameServerApp.getServerLogic();
+
+        var player = m_owner as Player;
+        var friend_cache_request = new FriendInterlockCacheRequest(m_owner, server_logic.getRedisConnector(), m_my_guid, m_friend_guid);
+        var result = await friend_cache_request.getLock();
+        if (result.isFail()) return result;
+
+        result = await doAction();
+        if (result.isFail()) return result;
+
+        await friend_cache_request.removeFirstCache();
+        return result;
+    }
+
+    protected Player getOwner()
+    {
+        var owner = m_owner as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        return owner;
+    }
+    
+    protected string getMyGuid() => m_my_guid;
+    protected string getFriendGuid() => m_friend_guid;
+    
+
+    
+}

GameServer/Contents/Friend/LockAction/RenameFriendFolderInterlockAction.cs

@@ -0,0 +1,42 @@
+using Google.Protobuf.WellKnownTypes;
+using ServerCommon;
+using ServerCommon.Cache;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class RenameFriendFolderInterlockAction : FriendInterlockBase
+    {
+        private FriendAttribute m_friend_attrib;
+        string m_new_folder_name;
+        public RenameFriendFolderInterlockAction(UserBase owner, string myGuid, FriendAttribute friendAttibute, string newFolderName) : base(owner, myGuid, friendAttibute.FriendGuid)
+        {
+            m_friend_attrib = friendAttibute;
+            m_new_folder_name = newFolderName;
+        }
+
+        public override async Task<Result> doAction()
+        {
+            await Task.CompletedTask;
+
+            var player = getOwner();
+
+            var friend_agent_action = player.getEntityAction<FriendAgentAction>();
+
+            var friend = friend_agent_action.getFriend(getFriendGuid());
+            NullReferenceCheckHelper.throwIfNull(friend, () => $"friend is null !!!");
+
+            var friend_attribute = friend.getEntityAttribute<FriendAttribute>();
+            NullReferenceCheckHelper.throwIfNull(friend_attribute, () => $"friend_attribute is null !!!");
+            friend_attribute.FolderName = m_new_folder_name;
+            friend_attribute.modifiedEntityAttribute();//이것도 안해도될듯
+
+            return new();
+        }
+    }
+}

GameServer/Contents/Friend/LockAction/ReplyFriendRequestLockAction.cs

@@ -0,0 +1,58 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class ReplyFriendRequestLockAction : FriendInterlockBase
+{
+    private Int32 m_reply_type = 1;
+    public ReplyFriendRequestLockAction(UserBase owner, string myGuid, string friendGuid, int replyType) : base(owner, myGuid, friendGuid)
+    {
+        m_reply_type = replyType;
+    }
+
+    public override async Task<Result> doAction()
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        var action = getOwner().getEntityAction<ReplyReceivedFriendRequestAction>();
+
+        var result = await action.replyReceivedFriendRequest(getMyGuid(), getFriendGuid(), m_reply_type);
+        if (result.isFail()) return result;
+
+        //거절은 딱히 DB 수정할것 없다. 
+        if(m_reply_type == (int)FriendRequestReplyType.Accept)
+        {
+            var batch = new QueryBatchEx<QueryRunnerWithDocument>(getOwner(), LogActionType.FriendAdd, server_logic.getDynamoDbClient());
+            {
+                batch.addQuery(new DBQAddFriend(getOwner().getUserGuid(), getFriendGuid()));
+            }
+            var log_invoker = new AddFriendBusinessLog(getOwner().getUserGuid(), getFriendGuid());
+            batch.appendBusinessLog(log_invoker);
+
+            result = await QueryHelper.sendQueryAndBusinessLog(batch);    
+        }
+
+        //거절 로그
+        if (m_reply_type == (int)FriendRequestReplyType.Refuse)
+        {
+            //log
+            List<ILogInvoker> invokers = new List<ILogInvoker>();
+            invokers.Add(new RefuseFriendRequestBusinessLog(getMyGuid(), getFriendGuid()));
+            var log_action = new LogActionEx(LogActionType.RefuseFriendRequest);
+            BusinessLogger.collectLogs(log_action, getOwner(), invokers);
+        }
+
+        return result;
+    }
+}
+
+

GameServer/Contents/Friend/LockAction/SendFriendRequestInterlockAction.cs

@@ -0,0 +1,35 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class SendFriendRequestInterlockAction : FriendInterlockBase
+{
+    private DateTime m_request_time;
+    public SendFriendRequestInterlockAction(UserBase owner, string myGuid, string friendGuid, DateTime requestTime) : base(owner, myGuid,friendGuid)
+    {
+        m_request_time = requestTime;
+    }
+
+    public override async Task<Result> doAction()
+    { 
+        var server_logic = GameServerApp.getServerLogic();
+
+        var owner = getOwner();
+
+        DateTime now = DateTimeHelper.Current;
+
+        var friend_request_cache = new FriendReqCacheRequest(owner, getMyGuid(), getFriendGuid(), server_logic.getRedisConnector());
+        var result = await friend_request_cache.addFriendRequest(owner.getUserGuid(), getFriendGuid(), now);
+
+        return result;
+    }
+}

GameServer/Contents/Friend/Log/AddFriendBusinessLog.cs

@@ -0,0 +1,31 @@
+using Google.Protobuf.WellKnownTypes;
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer;
+
+public class AddFriendBusinessLog  : ILogInvokerEx
+{
+    FriendLogInfo m_info;
+
+    public AddFriendBusinessLog(string myGuid, string friendGuid)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new FriendLogInfo(this, myGuid, friendGuid);
+    }   
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}
+

GameServer/Contents/Friend/Log/CancelFriendRequestBusinessLog.cs

@@ -0,0 +1,30 @@
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+
+namespace GameServer;
+
+public class CancelFriendRequestBusinessLog  : ILogInvokerEx
+{
+    FriendLogInfo m_info;
+    public CancelFriendRequestBusinessLog(string myGuid, string friendGuid)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new FriendLogInfo(this, myGuid, friendGuid);
+    }
+
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}
+

GameServer/Contents/Friend/Log/DeleteFriendBusinessLog.cs

@@ -0,0 +1,35 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class DeleteFriendBusinessLog  : ILogInvokerEx
+{
+    FriendLogInfo m_info;
+
+    public DeleteFriendBusinessLog(string myGuid, string friendGuid)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new FriendLogInfo(this, myGuid, friendGuid);
+    }
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+
+}

GameServer/Contents/Friend/Log/InviteFriendToMyhomeBusinessLog.cs

@@ -0,0 +1,27 @@
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer;
+
+public class InviteFriendToMyhomeBusinessLog  : ILogInvokerEx
+{
+    InviteFriendToMyhomeLogInfo m_info;
+    public InviteFriendToMyhomeBusinessLog(string myGuid, Dictionary<string, string> inviteResult)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new InviteFriendToMyhomeLogInfo(this, myGuid, inviteResult);
+    }
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}

GameServer/Contents/Friend/Log/KickFriendFromMyhomeBusinessLog.cs

@@ -0,0 +1,33 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class KickFriendFromMyhomeBusinessLog  : ILogInvokerEx
+{
+    KickFriendFromMyhomeLogInfo m_info;
+
+    public KickFriendFromMyhomeBusinessLog(KickFriendResult kickFriendResult) : base(LogDomainType.Friend)
+    {
+
+        m_info = new KickFriendFromMyhomeLogInfo(this, kickFriendResult.getNeedNotiMembers(), kickFriendResult.getErrorMembers());
+    }
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}

GameServer/Contents/Friend/Log/RefuseFriendRequestBusinessLog.cs

@@ -0,0 +1,27 @@
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer;
+
+public class RefuseFriendRequestBusinessLog  : ILogInvokerEx
+{
+    FriendLogInfo m_info;
+    public RefuseFriendRequestBusinessLog(string myGuid, string friendGuid)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new FriendLogInfo(this, myGuid, friendGuid);
+    }
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}

GameServer/Contents/Friend/Log/ReplyInviteMyhomeBuisinessLog.cs

@@ -0,0 +1,30 @@
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer;
+
+
+public class ReplyInviteMyhomeBuisinessLog  : ILogInvokerEx
+{
+    ReplyInviteMyhomeLogInfo m_info;
+     
+    public ReplyInviteMyhomeBuisinessLog(string myGuid, string friendGuid, Int32 replyValue)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new ReplyInviteMyhomeLogInfo(this, myGuid, friendGuid, replyValue);
+    }
+
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}

GameServer/Contents/Friend/Log/SendFriendRequestBusinessLog.cs

@@ -0,0 +1,32 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class SendFriendRequestBusinessLog  : ILogInvokerEx
+{
+    FriendLogInfo m_info;
+    public SendFriendRequestBusinessLog(string myGuid, string friendGuid)
+        : base(LogDomainType.Friend)
+    {
+        m_info = new FriendLogInfo(this, myGuid, friendGuid);
+    }
+
+    public override bool hasLog()
+    {
+        return true;
+    }
+
+    protected override void fillup(ref BusinessLog.LogBody body)
+    {
+        body.append(m_info);
+    }
+}

GameServer/Contents/Friend/PacketHandler/CancelFriendRequestPacketHandler.cs

@@ -0,0 +1,90 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.CancelFriendRequestReq), typeof(CancelFriendRequestPacketHandler), typeof(GameLoginListener))]
+public class CancelFriendRequestPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+
+        var target_guid = recv_msg.Request.CancelFriendRequestReq.Guid;
+
+        IFriendInterlockAction interlock_actioin = new CancelFriendRequestInterlockAction(owner, owner.getUserGuid(), target_guid);
+        var result = await interlock_actioin.doInterlockAction();
+        if (result.isFail())
+        {
+            send_GS2C_ACK_CANCLE_FRIEND_REQUEST(owner, result);
+            return result;
+        }
+
+        send_GS2C_ACK_CANCLE_FRIEND_REQUEST(owner, result);
+        
+        //상대방에게 삭제 됐다고 Noti
+        result = await send_GS2CS_NFT_CANCLE_FRIEND_REQUEST(owner, target_guid);
+        if (result.isFail())
+        {
+            Log.getLogger().error($"send_GS2CS_NFT_CANCLE_FRIEND_REQUEST send Fail, owner : {owner.toBasicString()}, target_guid : {target_guid}");
+        }
+        return result;
+    }
+
+    public async Task<Result> send_GS2CS_NFT_CANCLE_FRIEND_REQUEST(Player owner, string targetGuid)
+    {
+        ServerMessage notiMessage = new ServerMessage();
+        notiMessage.CancelFriendRequestNoti = new();
+        notiMessage.CancelFriendRequestNoti.SenderId = "";
+        notiMessage.CancelFriendRequestNoti.SenderGuid = owner.getUserGuid();
+        notiMessage.CancelFriendRequestNoti.SenderNickName = owner.getUserNickname();
+        notiMessage.CancelFriendRequestNoti.ReceiverId = "";
+        notiMessage.CancelFriendRequestNoti.ReceiverGuid = targetGuid;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbit_mq = GameServerApp.getServerLogic().getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null !!!");
+        var login_cache_request = new LoginCacheOtherUserRequest(owner, server_logic.getRedisConnector(), targetGuid);
+        var result = await login_cache_request.fetchLogin();
+        if (result.isSuccess())
+        {
+            var login_cache = login_cache_request.getLoginCache();
+            NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null !!!");
+            rabbit_mq.SendMessage(login_cache.CurrentServer, notiMessage);
+        }
+
+        return result;
+    }
+
+    public static Result send_GS2C_ACK_CANCLE_FRIEND_REQUEST(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.CancelFriendRequestRes = new();
+
+        //CancelFriendRequestRes
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_GS2C_ACK_CANCLE_FRIEND_REQUEST Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        return result;
+
+    }
+}

GameServer/Contents/Friend/PacketHandler/ChangeFriendFolderLoacationPacketHandler.cs

@@ -0,0 +1,46 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.MoveFriendFolderUserReq), typeof(ChangeFriendFolderLoacationPacketHandler), typeof(GameLoginListener))]
+public class ChangeFriendFolderLoacationPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.MoveFriendFolderUserReq;
+        var friend_guid = request.Guid;
+        var folder_name = request.FolderName;
+
+        IFriendInterlockAction interlock_action = new ChangeFriendFolderLocationInterlockAction(owner, owner.getUserGuid(), friend_guid, folder_name);
+        var result =  await interlock_action.doInterlockAction();
+
+        send_GS2C_ACK_CHANGE_FRIEND_FOLDER_LOCATION(owner, result);
+
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_CHANGE_FRIEND_FOLDER_LOCATION(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.MoveFriendFolderUserRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+        return true;
+    }
+
+
+}

GameServer/Contents/Friend/PacketHandler/ChangeFriendOrderPacketHandlercs.cs

@@ -0,0 +1,70 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ChangeFriendOrderReq), typeof(ChangeFriendOrderPacketHandler), typeof(GameLoginListener))]
+public class ChangeFriendOrderPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.ChangeFriendOrderReq;
+        var order_type = request.OrderType;
+
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "HoldFriendFolder", delegateChangeFriendOrder);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_CHANGE_FRIEND_ORDER(owner, result);
+            return result;
+        }
+
+        send_GS2C_ACK_CHANGE_FRIEND_ORDER(owner, result);
+
+        return result;
+
+
+        async Task<Result> delegateChangeFriendOrder() => await changeFriendOrder(owner, order_type);
+    }
+
+    private async Task<Result> changeFriendOrder(Player owner, Int32 orderType)
+    {
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        var result = friend_folder_action.changeOrderType(orderType);
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+        return result;
+
+    }
+
+
+        private static bool send_GS2C_ACK_CHANGE_FRIEND_ORDER(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ChangeFriendOrderRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+        return true;
+    }
+}

GameServer/Contents/Friend/PacketHandler/ConfirmNewFriendPacketHandler.cs

@@ -0,0 +1,71 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ConfirmNewFriendReq), typeof(ConfirmNewFriendPacketHandler), typeof(GameLoginListener))]
+public class ConfirmNewFriendPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.ConfirmNewFriendReq;
+
+        var friend_guids = request.Guids;
+        var my_guid = owner.getUserGuid();
+        foreach (var guid in friend_guids)
+        {
+            if(my_guid.Equals(guid)) continue;
+
+            IFriendInterlockAction interlock_action = new ConfirmNewFriendInterlockAction(owner, my_guid, guid);
+            result = await interlock_action.doInterlockAction();
+            if (result.isFail())
+            {
+                Log.getLogger().error($"ConfirmNewFriendPacketHandler onProcessPacket error my_guid : {my_guid}, guid : {guid}");
+                Log.getLogger().error(result.toBasicString());
+                continue;
+            }
+        }
+        send_GS2C_ACK_CONFIRM_NEW_FRIEND(owner, result);
+        return result;
+    }
+
+
+    
+
+    private static bool send_GS2C_ACK_CONFIRM_NEW_FRIEND(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ConfirmNewFriendRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) { return false; }
+        return true;
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

GameServer/Contents/Friend/PacketHandler/ConfirmNewReceivedFriendRequestPacketHandler.cs

@@ -0,0 +1,54 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ConfirmNewReceivedFriendRequestReq), typeof(ConfirmNewReceivedFriendRequestPacketHandler), typeof(GameLoginListener))]
+public class ConfirmNewReceivedFriendRequestPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+
+        var request = recv_msg.Request.ConfirmNewReceivedFriendRequestReq;
+        var guids = request.Guids;
+
+        
+        foreach (var guid in guids)
+        {
+            IFriendInterlockAction interlock_action = new ConfirmNewReceivedFriendRequestInterlockAction(owner, owner.getUserGuid(), guid);
+            result = await interlock_action.doInterlockAction();
+        }
+
+        
+
+        send_GS2C_ACK_CONFIRM_NEW_RECEIVED_FRIEND_REQUEST(owner);
+        return result;
+
+    }
+
+    private static bool send_GS2C_ACK_CONFIRM_NEW_RECEIVED_FRIEND_REQUEST(Player owner)
+    {
+        var result = new Result() ;
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ConfirmNewReceivedFriendRequestRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) { return false; }
+        return true;
+    }
+}

GameServer/Contents/Friend/PacketHandler/CreateFriendFolderPacketHandler.cs

@@ -0,0 +1,106 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.CreateFriendFolderReq), typeof(CreateFriendFolderPacketHandler), typeof(GameLoginListener))]
+public class CreateFriendFolderPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"player is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!! - {owner.toBasicString()}");
+
+        var request = recv_msg.Request.CreateFriendFolderReq;
+        var folder_name = request.FolderName;
+
+        var result = new Result();
+
+        result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CreateFriendFolder", delegateCreateFriendFolder);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_CREATE_FRIEND_FOLDER(owner, ref result);
+            return result;
+        }
+
+        var friend_action = owner.getEntityAction<FriendFolderAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null !!! - {owner.toBasicString()}");
+
+        var folder = friend_action.getFriendFolder(folder_name);
+        send_GS2C_ACK_CREATE_FRIEND_FOLDER(owner, folder, ref result);
+
+        return result;
+
+        async Task<Result> delegateCreateFriendFolder() => await createFriendFolder(owner, folder_name);
+    }
+
+    private async Task<Result> createFriendFolder(Player owner, string folderName)
+    {
+        var friend_action = owner.getEntityAction<FriendFolderAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"friend_action is null !!! - {owner.toBasicString()}");
+
+        var result = friend_action.addFriendFolder(folderName);
+        if (result.isFail()) return result;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_CREATE_FRIEND_FOLDER(Player owner, ServerCommon.FriendFolder? folder, ref Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.CreateFriendFolderRes = new();
+
+        if (folder is not null)
+        {
+            ack_packet.Response.CreateFriendFolderRes.FriendFolder = new();
+            ack_packet.Response.CreateFriendFolderRes.FriendFolder.FolderName = folder.FolderName;
+            ack_packet.Response.CreateFriendFolderRes.FriendFolder.IsHold = folder.IsHold;
+            ack_packet.Response.CreateFriendFolderRes.FriendFolder.CreateTime = Timestamp.FromDateTime(folder.CreateTime);
+            ack_packet.Response.CreateFriendFolderRes.FriendFolder.HoldTime = Timestamp.FromDateTime(folder.HoldTime);
+        }
+
+        return sendAckPacket(owner, ack_packet);
+    }
+
+    private static bool send_GS2C_ACK_CREATE_FRIEND_FOLDER(Player owner, ref Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.CreateFriendFolderRes = new();
+
+        return sendAckPacket(owner, ack_packet);
+
+
+    }
+
+    private static bool sendAckPacket(Player owner, ClientToGame ackPacket)
+    {
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ackPacket)) return false;
+
+        return true;
+    }
+
+}

GameServer/Contents/Friend/PacketHandler/DeleteFriendFolderPacketHandler.cs

@@ -0,0 +1,70 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.DeleteFriendFolderReq), typeof(DeleteFriendFolderPacketHandler), typeof(GameLoginListener))]
+public class DeleteFriendFolderPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!! - {owner.toBasicString()}");
+
+        var request = recv_msg.Request.DeleteFriendFolderReq;
+        var folder_name = request.FolderName;
+
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        var server_logic = GameServerApp.getServerLogic();
+        var my_guid = owner.getUserGuid();
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "DeleteFriendFolder", delegateDeleteFriendFolder);
+        send_GS2C_ACK_DELETE_FRIEND_FOLDER_LOCATION(owner, result);
+        return result;
+
+        async Task<Result> delegateDeleteFriendFolder() => await deleteFriendFolder(owner, my_guid, folder_name);
+    }
+
+    private async Task<Result> deleteFriendFolder(Player owner, string myGuid, string folderName)
+    {
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_folder_action, () => $"friend_folder_action is null !!! - {owner.toBasicString()}");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var result = await friend_folder_action.deleteFriendFolder(myGuid, folderName);
+
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_DELETE_FRIEND_FOLDER_LOCATION(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.DeleteFriendFolderRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+
+        return true;
+    }
+
+    
+}

GameServer/Contents/Friend/PacketHandler/DeleteFriendPacketHandler.cs

@@ -0,0 +1,92 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.DeleteFriendReq), typeof(DeleteFriendPacketHandler), typeof(GameLoginListener))]
+public class DeleteFriendPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!! - {owner.toBasicString()}");
+
+        var request = recv_msg.Request.DeleteFriendReq;
+        var delete_guid = request.Guid;
+        var my_guid = owner.getUserGuid();
+
+        var server_logic = GameServerApp.getServerLogic();
+
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "DeleteFriend", delegateDeleteFriend);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_DELETE_FRIEND(owner, result);
+            return result;
+        }
+        send_GS2C_ACK_DELETE_FRIEND(owner, result);
+
+        //상대방에게도 삭제 됐다고 Noti 보낸다
+        await send_GS2CS_NTF_DELETE_FRIEND(owner, my_guid, delete_guid);
+
+        await QuestManager.It.QuestCheck(owner, new QuestFriend(EQuestEventTargetType.FRIEND, EQuestEventNameType.DELETED));
+
+        return result;
+
+        async Task<Result> delegateDeleteFriend() => await deleteFriend(owner, my_guid, delete_guid);
+    }
+
+    public static async Task send_GS2CS_NTF_DELETE_FRIEND(Player owner, string myGuid, string deleteGuid)
+    {
+        ServerMessage deleteNoti = new ServerMessage();
+        deleteNoti.FriendDeleteNoti = new();
+        deleteNoti.FriendDeleteNoti.SenderId = myGuid;
+        deleteNoti.FriendDeleteNoti.SenderGuid = myGuid;
+        deleteNoti.FriendDeleteNoti.SenderNickName = owner.getUserNickname();
+        deleteNoti.FriendDeleteNoti.ReceiverId = "";
+        deleteNoti.FriendDeleteNoti.ReceiverGuid = deleteGuid;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null !!! - {owner.toBasicString()}");
+
+        var login_cache_request = new LoginCacheOtherUserRequest(owner, server_logic.getRedisConnector(), deleteGuid);
+        var result = await login_cache_request.fetchLogin();
+        if (result.isSuccess())
+        {
+            var login_cache = login_cache_request.getLoginCache();
+            NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null !!! - {owner.toBasicString()}");
+
+            rabbit_mq.SendMessage(login_cache.CurrentServer, deleteNoti);
+        }
+    }
+
+    private async Task<Result> deleteFriend(Player owner, string myGuid, string deleteGuid)
+    {
+        IFriendInterlockAction interlock_action = new DeleteFriendInterlockAction(owner, myGuid, deleteGuid);
+        var result = await interlock_action.doInterlockAction();
+
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_DELETE_FRIEND(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.DeleteFriendRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+
+        return true;
+    }
+}

GameServer/Contents/Friend/PacketHandler/GetFriendFoldersPacketHandler.cs

@@ -0,0 +1,89 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.GetFriendFolderListReq), typeof(GetFriendFoldersPacketHandler), typeof(GameLoginListener))]
+internal class GetFriendFoldersPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"Player is null");
+
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_folder_action, () => $"friend folder action is null !!! - {owner.toBasicString()}");
+
+        var result =  await friend_folder_action.loadFriendFolder();
+        if (result.isFail())
+        {
+            send_GS2C_ACK_FRIEND_FOLDER_LIST(owner, result);
+            return result;
+        }
+
+        send_GS2C_ACK_FRIEND_FOLDER_LIST_BY_SUCCESS(owner, result);
+
+        return result;
+
+    }
+
+    public static Result send_GS2C_ACK_FRIEND_FOLDER_LIST(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.GetFriendFolderListRes = new ClientToGameRes.Types.GetFriendFolderListRes();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_S2C_ACK_FRIEND_FOLDER_LIST Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        return result;
+    }
+
+    public static Result send_GS2C_ACK_FRIEND_FOLDER_LIST_BY_SUCCESS(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.GetFriendFolderListRes = new ClientToGameRes.Types.GetFriendFolderListRes();
+        
+
+        var friend_folder_attribute = owner.getEntityAttribute<FriendFolderAttribute>();
+        NullReferenceCheckHelper.throwIfNull(friend_folder_attribute, () => $"FriendFolderAttribute is null - player: {owner.toBasicString()}");
+
+
+        ack_packet.Response.GetFriendFolderListRes.FolderOrderType = friend_folder_attribute.m_folder_order_type;
+        foreach (var folder in friend_folder_attribute.m_folders.Values)
+        {
+            FriendFolder friendFolder = new FriendFolder();
+            friendFolder.FolderName = folder.FolderName;
+            friendFolder.IsHold = folder.IsHold;
+            friendFolder.HoldTime = Timestamp.FromDateTime(folder.HoldTime);
+            friendFolder.CreateTime = Timestamp.FromDateTime(folder.CreateTime);
+            ack_packet.Response.GetFriendFolderListRes.FriendFolderList.Add(friendFolder);
+        }   
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_S2C_ACK_FRIEND_FOLDER_LIST Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            
+            return result;
+        }
+
+        return result;
+    }
+}

GameServer/Contents/Friend/PacketHandler/GetFriendsPacketHandler.cs

@@ -0,0 +1,78 @@
+using Google.Protobuf;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.GetFriendListReq), typeof(GetFriendsPacketHandler), typeof(GameLoginListener))]
+public class GetFriendsPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => "Player is null !!!");
+
+        var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_agent_action, () => $"FriendAgentAction is null !!! - player:{owner.toBasicString()}");
+
+        var result = await friend_agent_action.loadFriends();
+        if (result.isFail())
+        {
+            send_GS2C_ACK_FRIENDS(owner, result);
+            return result;
+        }
+
+        var friend_infos = await friend_agent_action.getFriendsInfo();
+
+        send_GS2C_ACK_FRIENDS(owner, friend_infos, result);
+
+        return result;
+    }
+
+
+    public static Result send_GS2C_ACK_FRIENDS(Player owner, List<FriendInfo> friendInfos, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.GetFriendListRes = new ClientToGameRes.Types.GetFriendListRes();
+        ack_packet.Response.GetFriendListRes.FriendList.AddRange(friendInfos);
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_GS2C_ACK_FRIENDS Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        return result;
+
+    }
+
+    public static Result send_GS2C_ACK_FRIENDS(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.GetFriendListRes = new ClientToGameRes.Types.GetFriendListRes();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_GS2C_ACK_FRIENDS Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+        return result;
+    }
+
+
+}

GameServer/Contents/Friend/PacketHandler/GetReceivedFriendRequestsPacketHandler.cs

@@ -0,0 +1,72 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.GetReceivedFriendRequestListReq), typeof(GetReceivedFriendRequestsPacketHandler), typeof(GameLoginListener))]
+public class GetReceivedFriendRequestsPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"Player is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        FriendReqCacheRequest cache = new FriendReqCacheRequest(owner, owner.getUserGuid(), "", server_logic.getRedisConnector());
+
+        var infos = await cache.getReceivedFriendRequests();
+
+        await send_GS2C_ACK_RECEIVED_FRIEND_REQUEST(owner, result, infos);
+
+        return result;
+    }
+
+    public static async Task<Result> send_GS2C_ACK_RECEIVED_FRIEND_REQUEST(Player owner, Result result, List<FriendRequestCache> friendRquests)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.GetReceivedFriendRequestListRes = new();
+
+
+        foreach (var request in friendRquests)
+        {
+            
+            FriendRequestInfo info = new();
+            var (nick_result, nick_attrib ) = await NicknameDoc.findNicknameFromGuid(request.m_sender_guid);
+            if (nick_result.isFail() || null == nick_attrib)
+            {
+                info.NickName = string.Empty;
+            }
+            else
+            {
+                info.NickName = nick_attrib.Nickname;
+            }
+            info.RequestTime = Timestamp.FromDateTime(request.m_request_time);
+            info.Guid = request.m_sender_guid;
+            info.IsNew = request.m_is_new;
+            ack_packet.Response.GetReceivedFriendRequestListRes.RequestList.Add(info);
+        }
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_GS2C_ACK_RECEIVED_FRIEND_REQUEST Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        return result;
+    }
+
+}
+
+
+

GameServer/Contents/Friend/PacketHandler/GetSendedFriendRequestsPacketHandler.cs

@@ -0,0 +1,70 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.GetSendedFriendRequestListReq), typeof(GetSendedFriendRequestsPacketHandler), typeof(GameLoginListener))]
+internal class GetSendedFriendRequestsPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"Player is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        var server_logic = GameServerApp.getServerLogic();
+
+        FriendReqCacheRequest cache = new FriendReqCacheRequest(owner, owner.getUserGuid(), "", server_logic.getRedisConnector());
+
+        var infos = await cache.getSendedFriendRequests();
+
+        await send_GS2C_ACK_SENDED_FRIEND_REQUEST(owner, result, infos);
+
+        return result;
+    }
+
+    public static async Task<Result> send_GS2C_ACK_SENDED_FRIEND_REQUEST(Player owner, Result result, List<FriendRequestCache> friendRquests)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.GetSendedFriendRequestListRes = new();
+
+        foreach (var request in friendRquests)
+        {
+            FriendRequestInfo info = new();
+            var (nick_result, nick_attrib) = await NicknameDoc.findNicknameFromGuid(request.m_receiver_guid);
+            if (nick_result.isFail() || null == nick_attrib)
+            {
+                info.NickName = string.Empty;
+            }
+            else
+            {
+                info.NickName = nick_attrib.Nickname;
+            }
+            info.RequestTime = Timestamp.FromDateTime(request.m_request_time);
+            info.Guid = request.m_receiver_guid;
+            info.IsNew = request.m_is_new;
+            ack_packet.Response.GetSendedFriendRequestListRes.RequestList.Add(info);
+        }
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet))
+        {
+            string err_msg = $"send_GS2C_ACK_SENDED_FRIEND_REQUEST Fail !!! : owner:{owner.toBasicString()}";
+            result.setFail(ServerErrorCode.ProudNetException, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        return result;
+    }
+}

GameServer/Contents/Friend/PacketHandler/HoldFriendFolderPacketHandler.cs

@@ -0,0 +1,113 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.HoldFriendFolderReq), typeof(HoldFriendFolderPacketHandler), typeof(GameLoginListener))]
+public class HoldFriendFolderPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"player is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"ClientToGmae message is null !!! - player:{owner.toBasicString()}");
+        
+        var request = recv_msg.Request.HoldFriendFolderReq;
+        var folder_name = request.FolderName;
+
+        var friend_action = owner.getEntityAction<FriendFolderAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"FriendFolderAction is null !!! - player:{owner.toBasicString()}");
+
+
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "HoldFriendFolder", delegateHoldFriendFolder);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_HOLD_FRIEND_FOLDER(owner, ref result);
+            return result;
+        }
+
+        ServerCommon.FriendFolder? folder = friend_action.getFriendFolder(folder_name);
+        send_GS2C_ACK_HOLD_FRIEND_FOLDER(owner, folder, ref result);
+        
+        return result;
+
+
+        async Task<Result> delegateHoldFriendFolder() => await holdFriendFolder(owner, folder_name);
+    }
+
+    private async Task<Result> holdFriendFolder(Player owner, string folderName)
+    {
+        var friend_action = owner.getEntityAction<FriendFolderAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_action, () => $"FriendFolderAction is null !!! - player:{owner.toBasicString()}");
+
+        var result = friend_action.holdFriendFolder(folderName);
+        if (result.isFail())
+        {
+            return result;
+        }
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+
+        if (result.isFail())
+        {
+            Log.getLogger().error($"holdFriendFolder fail. {result.ErrorCode}");
+            return result;
+        }
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_HOLD_FRIEND_FOLDER(Player owner, ServerCommon.FriendFolder? folder, ref Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.HoldFriendFolderRes = new();
+        ack_packet.Response.HoldFriendFolderRes.FriendFolder = new();
+
+
+        if (folder is not null)
+        {
+            ack_packet.Response.HoldFriendFolderRes.FriendFolder.FolderName = folder.FolderName;
+            ack_packet.Response.HoldFriendFolderRes.FriendFolder.IsHold = folder.IsHold;
+            ack_packet.Response.HoldFriendFolderRes.FriendFolder.CreateTime = Timestamp.FromDateTime(folder.CreateTime); ;
+            ack_packet.Response.HoldFriendFolderRes.FriendFolder.HoldTime = Timestamp.FromDateTime(folder.HoldTime);
+        }
+        return sendAckPacket(owner, ack_packet);
+    }
+
+    private static bool send_GS2C_ACK_HOLD_FRIEND_FOLDER(Player owner, ref Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.HoldFriendFolderRes = new();
+
+        return sendAckPacket(owner, ack_packet);
+
+
+    }
+
+    private static bool sendAckPacket(Player owner, ClientToGame ackPacket)
+    {
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ackPacket)) return false;
+
+        return true;
+    }
+
+}

GameServer/Contents/Friend/PacketHandler/InviteFriendToMyhomePacketHandler.cs

@@ -0,0 +1,146 @@
+using Newtonsoft.Json;
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+using static ServerMessage.Types;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.InviteFriendToMyhomeReq), typeof(InviteFriendToMyhomePacketHandler), typeof(GameLoginListener))]
+public class InviteFriendToMyhomePacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession entityWithSession, IMessage recvMessage)
+    {
+        var player = entityWithSession as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !");
+
+        var recv_msg = recvMessage as ClientToGame;
+        ArgumentNullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!! - {player.toBasicString()}");
+        var request = recv_msg.Request.InviteFriendToMyhomeReq;
+        ArgumentNullReferenceCheckHelper.throwIfNull(request, () => $"recv_msg is null !!! - {player.toBasicString()}");
+
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var player_action = player.getEntityAction<PlayerAction>();
+        NullReferenceCheckHelper.throwIfNull(player_action, () => $"player_action is null !!! - {player.toBasicString()}");
+
+        var selected_character = player_action.getSelectedCharacter();
+        if (null == selected_character)
+        {
+            err_msg = $"Not selected Character !!! - {player.toBasicString()}";
+            result.setFail(ServerErrorCode.CharacterNotSelected, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            send_GS2C_ACK_INVITE_FRIEND_TO_MYHOME(player, result);
+            return result;
+        }
+
+        var character_action = selected_character.getEntityAction<CharacterAction>();
+        NullReferenceCheckHelper.throwIfNull(character_action, () => $"character_action is null !!! - {selected_character.toBasicString()}");
+        if (character_action.isFarming())
+        {
+            err_msg = $"Character is Farming !!! - {selected_character.toBasicString()}, {player.toBasicString()}";
+            result.setFail(ServerErrorCode.FarimgState, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            send_GS2C_ACK_INVITE_FRIEND_TO_MYHOME(player, result);
+            return result;
+        }
+
+        var friend_infos = request.Infos.ToList();
+        
+        var friend_myhome_action = player.getEntityAction<FriendInviteMyhomeAction>();
+        NullReferenceCheckHelper.throwIfNull(friend_myhome_action, () => $"friend_myhome_action is null !!! - {player.toBasicString()}");
+
+        (result, var fail_infos, var noti_infos) = await friend_myhome_action.inviteFriendToMyhome(friend_infos);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_INVITE_FRIEND_TO_MYHOME(player, result);
+            return result;
+        }
+
+        send_GS2C_ACK_INVITE_FRIEND_TO_MYHOME(player, fail_infos, noti_infos);
+
+        //초대 Noti 전송
+        await send_GS2C_NTF_RECEIVE_INVITE_MYHOME(player, noti_infos);
+
+        //로그 
+        var invokers = new List<ILogInvoker>();
+        Dictionary<string, string> invite_result = new Dictionary<string, string>();
+        foreach (var noti in noti_infos)
+        {
+            invite_result.Add(noti.BaseInfo.ReceiverGuid, ServerErrorCode.Success.ToString());
+        }
+        foreach (var fail_info in fail_infos)
+        {
+            invite_result.Add(fail_info.Guid, fail_info.ErrorCode.ToString());
+        }
+        invokers.Add(new InviteFriendToMyhomeBusinessLog(player.getUserGuid(), invite_result));
+
+        var log_action = new LogActionEx(LogActionType.RefuseFriendRequest);
+        BusinessLogger.collectLogs(log_action, player, invokers);
+
+        return result;
+    }
+
+
+    private async Task<bool> send_GS2C_NTF_RECEIVE_INVITE_MYHOME(Player owner, List<ReceiveInviteMyHomeNoti> noties)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit mq is null !! - player:{owner.toBasicString()}");
+
+        foreach (var noti in noties)
+        {
+            ServerMessage messgae = new ServerMessage();
+            messgae.ReceiveInviteMyHomeNoti = noti;
+
+            var login_cache_request = new LoginCacheOtherUserRequest(owner, server_logic.getRedisConnector(), noti.BaseInfo.ReceiverGuid);
+            var result = await login_cache_request.fetchLogin();
+            if (result.isFail())
+            {
+                Log.getLogger().info($"send_GS2C_NTF_RECEIVE_INVITE_MYHOME - fetchLogin fail - {result.ErrorCode}, noti : {JsonConvert.SerializeObject(noti)}");
+                continue;
+            }
+            var login_cache = login_cache_request.getLoginCache();
+            NullReferenceCheckHelper.throwIfNull(login_cache, () => $"LoginCache is null !! - player:{owner.toBasicString()}");
+
+            rabbit_mq.SendMessage(login_cache.CurrentServer, messgae);
+        }
+        return true;
+    }
+
+    private static bool send_GS2C_ACK_INVITE_FRIEND_TO_MYHOME(Player owner, Result result)
+    {
+        ClientToGame ack_packet = new();
+        ack_packet.Response = new();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.InviteFriendToMyhomeRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+        return true;
+
+    }
+
+    private static bool send_GS2C_ACK_INVITE_FRIEND_TO_MYHOME(Player owner, List<FriendErrorMember> failInfos, List<ReceiveInviteMyHomeNoti> noties)
+    {
+        ClientToGame ack_packet = new();
+        ack_packet.Response = new();
+        ack_packet.Response.ErrorCode = ServerErrorCode.Success;
+        ack_packet.Response.InviteFriendToMyhomeRes = new();
+        ack_packet.Response.InviteFriendToMyhomeRes.FailInfos.AddRange(failInfos);
+        ack_packet.Response.InviteFriendToMyhomeRes.SuccessGuids.AddRange(noties.Select(x => x.BaseInfo.ReceiverGuid));
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+        return true;
+
+    }
+}

GameServer/Contents/Friend/PacketHandler/KickFriendsFromMyHomePacketHandler.cs

@@ -0,0 +1,71 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.KickFriendsFromMyHomeReq), typeof(KickFriendsFromMyHomePacketHandler), typeof(GameLoginListener))]
+public class KickFriendsFromMyHomePacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => "Player is null !!!");
+
+        var my_guid = owner.getUserGuid();
+
+        var kick_friend_from_myhome_action = owner.getEntityAction<KickFriendsFromMyHomeAction>();
+        NullReferenceCheckHelper.throwIfNull(kick_friend_from_myhome_action, () => $"KickFriendsFromMyHomeAction is null !!! - player:{owner.toBasicString()}");
+
+        KickFriendResult kick_friend_result = new();
+        var result = await kick_friend_from_myhome_action.setKickableFriendsInfo(kick_friend_result);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_KICK_FRIENDS_FROM_MYHOME(owner, result);
+            return result;
+        }
+        send_GS2C_ACK_KICK_FRIENDS_FROM_MYHOME(owner, result, kick_friend_result);
+
+        await kick_friend_from_myhome_action.sendKickNoti(kick_friend_result);
+
+        //log
+        List<ILogInvoker> invokers = new List<ILogInvoker>();
+        invokers.Add(new KickFriendFromMyhomeBusinessLog(kick_friend_result));
+        var log_action = new LogActionEx(LogActionType.KickFriendsFromMyhome);
+        BusinessLogger.collectLogs(log_action, owner, invokers);
+
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_KICK_FRIENDS_FROM_MYHOME(Player owner, Result result, KickFriendResult kickFriendResult)
+    {
+        ClientToGame ack_packet = new();
+        ack_packet.Response = new();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.KickFriendsFromMyHomeRes = new();
+        ack_packet.Response.KickFriendsFromMyHomeRes.FailInfos.AddRange(kickFriendResult.getErrorMembers());
+        ack_packet.Response.KickFriendsFromMyHomeRes.SuccessGuids.AddRange(kickFriendResult.getNeedNotiMembers());
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+
+        return true;
+    }
+
+    private static bool send_GS2C_ACK_KICK_FRIENDS_FROM_MYHOME(Player owner, Result result)
+    {
+        ClientToGame ack_packet = new();
+        ack_packet.Response = new();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.KickFriendsFromMyHomeRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+
+        return true;
+    }
+}

GameServer/Contents/Friend/PacketHandler/ReleaseFriendFolderPacketHandler.cs

@@ -0,0 +1,105 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ReleaseFriendFolderReq), typeof(ReleaseFriendFolderPacketHandler), typeof(GameLoginListener))]
+public class ReleaseFriendFolderPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.ReleaseFriendFolderReq;
+        var folder_name = request.FolderName;
+        
+        var result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "ReleaseFriendFolder", delegateReleaseFriendFolder);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_RELEASE_FRIEND_FOLDER(owner, ref result);
+            return result;
+        }
+
+        var friend_action = owner.getEntityAction<FriendFolderAction>();
+        ServerCommon.FriendFolder? folder = friend_action.getFriendFolder(folder_name);
+        send_GS2C_ACK_RELEASE_FRIEND_FOLDER(owner, folder, ref result);
+
+        return result;
+
+
+        async Task<Result> delegateReleaseFriendFolder() => await releaseFriendFolder(owner, folder_name);
+    }
+
+    private async Task<Result> releaseFriendFolder(Player owner, string folderName)
+    {
+        var friend_action = owner.getEntityAction<FriendFolderAction>();
+
+        var result = friend_action.releaseFriendFolder(folderName);
+        if (result.isFail()) return result;
+
+
+        var server_logic = GameServerApp.getServerLogic();
+        var batch = new QueryBatchEx<QueryRunnerWithDocument>(owner, LogActionType.None, server_logic.getDynamoDbClient());
+        {
+            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+        }
+        result = await QueryHelper.sendQueryAndBusinessLog(batch);
+        if (result.isFail())
+        {
+            Log.getLogger().error($"ReleaseFriendFolderPacketHandler.releaseFriendFolder fail. {result.ErrorCode}");
+            return result;
+        }
+
+        return result;
+    }
+
+
+
+    private static bool send_GS2C_ACK_RELEASE_FRIEND_FOLDER(Player owner, ServerCommon.FriendFolder? folder, ref Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ReleaseFriendFolderRes = new();
+
+        if (folder is not null)
+        {
+            ack_packet.Response.ReleaseFriendFolderRes.FriendFolder = new();
+            ack_packet.Response.ReleaseFriendFolderRes.FriendFolder.FolderName = folder.FolderName;
+            ack_packet.Response.ReleaseFriendFolderRes.FriendFolder.IsHold = folder.IsHold;
+            ack_packet.Response.ReleaseFriendFolderRes.FriendFolder.CreateTime = Timestamp.FromDateTime(folder.CreateTime);
+            ack_packet.Response.ReleaseFriendFolderRes.FriendFolder.HoldTime = Timestamp.FromDateTime(folder.HoldTime);
+        }
+        return sendAckPacket(owner, ack_packet);
+    }
+
+    private static bool send_GS2C_ACK_RELEASE_FRIEND_FOLDER(Player owner, ref Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ReleaseFriendFolderRes = new();
+
+        return sendAckPacket(owner, ack_packet);
+
+
+    }
+
+    private static bool sendAckPacket(Player owner, ClientToGame ackPacket)
+    {
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ackPacket)) return false;
+
+        return true;
+    }
+
+}

GameServer/Contents/Friend/PacketHandler/RenameFriendFolderPacketHandler.cs

@@ -0,0 +1,99 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ReNameFriendFolderReq), typeof(RenameFriendFolderPacketHandler), typeof(GameLoginListener))]
+public class RenameFriendFolderPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.ReNameFriendFolderReq;
+        var old_folder_name = request.FolderName;
+        var new_folder_name = request.NewFolderName;
+
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        var result = friend_folder_action.renameFriendFolderConditionCheck(old_folder_name, new_folder_name);
+        string my_guid = owner.getUserGuid();
+        if (result.isFail())
+        {
+            send_GS2C_ACK_RENAME_FRIEND_FOLDER_LOCATION(owner, result);
+            return result;
+        }
+
+        result = await owner.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "RenameFriendFolder", delegateRenameFriendFolder);
+        if(result.isFail())
+        {
+            send_GS2C_ACK_RENAME_FRIEND_FOLDER_LOCATION(owner, result);
+            return result;
+        }
+
+        ServerCommon.FriendFolder? folder = friend_folder_action.getFriendFolder(new_folder_name);
+        send_GS2C_ACK_RENAME_FRIEND_FOLDER_LOCATION(owner, folder, result);
+
+
+        return result;
+
+        async Task<Result> delegateRenameFriendFolder() => await renameFriendFolder(owner, my_guid, old_folder_name, new_folder_name);
+    }
+
+    public async Task<Result> renameFriendFolder(
+        Player owner, 
+        string myGuid,
+        string oldFolderName, 
+        string newFolderName)
+    {
+        var friend_folder_action = owner.getEntityAction<FriendFolderAction>();
+        var result = await friend_folder_action.renameFriendFolder(myGuid, oldFolderName, newFolderName);
+        if(result.isFail()) return result; 
+        
+        return result;
+    }
+
+    private static bool send_GS2C_ACK_RENAME_FRIEND_FOLDER_LOCATION(Player owner, ServerCommon.FriendFolder? folder, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ReNameFriendFolderRes = new();
+
+        if (folder is not null)
+        {
+            ack_packet.Response.ReNameFriendFolderRes.FriendFolder = new();
+            ack_packet.Response.ReNameFriendFolderRes.FriendFolder.FolderName = folder.FolderName;
+            ack_packet.Response.ReNameFriendFolderRes.FriendFolder.IsHold = folder.IsHold;
+            ack_packet.Response.ReNameFriendFolderRes.FriendFolder.CreateTime = Timestamp.FromDateTime(folder.CreateTime);
+            ack_packet.Response.ReNameFriendFolderRes.FriendFolder.HoldTime = Timestamp.FromDateTime(folder.HoldTime);
+        }
+        return sendAckPacket(owner, ack_packet);
+    }
+
+    private static bool send_GS2C_ACK_RENAME_FRIEND_FOLDER_LOCATION(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ReNameFriendFolderRes = new();
+
+        return sendAckPacket(owner, ack_packet);
+    }
+
+    private static bool sendAckPacket(Player owner, ClientToGame ackPacket)
+    {
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ackPacket)) return false;
+
+        return true;
+    }
+}

GameServer/Contents/Friend/PacketHandler/ReplyInviteMyhomePacketHandler.cs

@@ -0,0 +1,170 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+using static ClientToGameReq.Types;
+using static ClientToGameRes.Types;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ReplyInviteMyhomeReq), typeof(ReplyInviteMyhomePacketHandler), typeof(GameLoginListener))]
+public class ReplyInviteMyhomePacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession entityWithSession, IMessage recvMessage)
+    {
+        var player = entityWithSession as Player;
+        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!! - {player.toBasicString()}");
+        var request = recv_msg.Request.ReplyInviteMyhomeReq;
+        NullReferenceCheckHelper.throwIfNull(request, () => $"request is null !!! - {player.toBasicString()}");
+
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var player_action = player.getEntityAction<PlayerAction>();
+
+        var selected_character = player_action.getSelectedCharacter();
+        if (null == selected_character)
+        {
+            err_msg = $"Not selected Character !!! - {player.toBasicString()}";
+            result.setFail(ServerErrorCode.CharacterNotSelected, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            send_GS2C_ACK_REPLY_INVITE_MYHOME(player, result);
+            return result;
+        }
+
+        var character_action = selected_character.getEntityAction<CharacterAction>();
+        NullReferenceCheckHelper.throwIfNull(character_action, () => $"character_action is null !!! - {selected_character.toBasicString()}");
+        
+        var my_guid = player.getUserGuid();
+        var reply_value = request.AcceptOrRefuse;
+        var reply_ref = new FriendReplyInviteMyhomeRefference(reply_value);
+        var invitor_id = request.SenderId;
+
+        var room_id = request.InstanceRoomId;
+        var friend_myhome_action = player.getEntityAction<FriendReplyInviteMyhomeAction>();
+        result = await friend_myhome_action.checkReplyableAboutInvite(room_id, invitor_id, reply_ref);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_REPLY_INVITE_MYHOME(player, result);
+            return result;
+        }
+
+        NullReferenceCheckHelper.throwIfNull(reply_ref.m_invitor_login_cache_nullable, () => $"reply_ref.m_invitor_login_cache_nullable is null !!!");
+
+        var invitor_login_cache = reply_ref.m_invitor_login_cache_nullable.getLoginCache();
+        NullReferenceCheckHelper.throwIfNull(invitor_login_cache, () => $"invitor_login_cache is null !!!");
+
+        if (character_action.isFarming())
+        {
+            //파밍중이면 클라에서 요청을 받았을때 알아서 reply 4로 보내주기때문에 여기서 리턴 처리만 정상처리로 보낸다.
+            //err_msg = $"Character is Farming !!! - {selected_character.toBasicString()}, {player.toBasicString()}";
+            //result.setFail(ServerErrorCode.FarimgState, err_msg);
+            //Log.getLogger().error(result.toBasicString());
+            send_GS2C_ACK_REPLY_INVITE_MYHOME(player, result);
+            //초대한 유저에게 에게 거절한 내용 전달
+            send_GS2C_NTF_REPLY_INVITE_MYHOME(my_guid, reply_value, invitor_login_cache);
+            return result;
+        }
+        
+        if (reply_value == (int)InviteFriendReplyType.Accept)
+        {
+            result = friend_myhome_action.acceptReply(reply_ref);
+
+            //에러든 아니든 여기서 리턴
+            send_GS2C_ACK_REPLY_INVITE_MYHOME(player, result);
+            if (result.isFail()) return result; 
+
+
+            //초대한 유저에게 에게 수락한 내용 전달
+            send_GS2C_NTF_REPLY_INVITE_MYHOME(my_guid, reply_value, invitor_login_cache);
+                
+
+            //친구 마이홈으로 이동하기 위한 처리 
+            result = await friend_myhome_action.joinFriendMyhomeFromInvite(room_id, reply_ref);
+            if (result.isFail()) return result;
+
+            result = MyhomeHelper.getMyhomeOwnerUserGuidAndMyhomeGuidFromRoomId(room_id, out var myhome_owner_user_guid, out _);
+            if (result.isFail()) return result;
+
+            (result, var myhome_attrib) = await MyhomeHelper.getEnterMyhomeAttribFromDynamoDb(myhome_owner_user_guid);
+            if (result.isFail()) return result;
+
+            var server_connect_info = reply_ref.m_server_connect_info_nullable;
+
+            NullReferenceCheckHelper.throwIfNull(server_connect_info, () => $"server_connect_info is null !!!");
+
+            send_GS2C_NTF_FRIEND_MYHOME_INFO_NOTI(player, server_connect_info);
+
+            await QuestManager.It.QuestCheck(player, new QuestMyHome(EQuestEventTargetType.MYHOME, EQuestEventNameType.ENTERED, "OTHERS"));
+        }
+        else
+        {
+            //초대한 유저에게 에게 거절한 내용 전달
+            send_GS2C_NTF_REPLY_INVITE_MYHOME(my_guid, reply_value, invitor_login_cache);
+            
+        }
+
+        List<ILogInvoker> invokers = new List<ILogInvoker>();
+        invokers.Add(new ReplyInviteMyhomeBuisinessLog(my_guid, invitor_login_cache.UserGuid, reply_value));
+        var log_action = new LogActionEx(LogActionType.RefuseFriendRequest);
+        BusinessLogger.collectLogs(log_action, player, invokers);
+
+        return result;
+    }
+
+    private static bool send_GS2C_NTF_FRIEND_MYHOME_INFO_NOTI(Player owner, ServerConnectInfo serverConnectInfo)
+    {
+        ClientToGame ntf_packet = new ClientToGame();
+        ntf_packet.Message = new ClientToGameMessage();
+        ntf_packet.Message.FriendMyhomeInfoNoti = new();
+        ntf_packet.Message.FriendMyhomeInfoNoti.InstanceServerConnectInfo = serverConnectInfo;
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ntf_packet)) return false;
+
+        return true;
+    }
+
+    private static bool send_GS2C_ACK_REPLY_INVITE_MYHOME(Player owner, Result result)
+    {
+        ClientToGame ack_packet = new();
+        ack_packet.Response = new();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ReplyInviteMyhomeRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) return false;
+
+        return true;
+    }
+
+
+    private static bool send_GS2C_NTF_REPLY_INVITE_MYHOME(string myGuid, Int32 replyValue, LoginCache invitor_cache)
+    {
+        ServerMessage message = new ServerMessage();
+        message.ReplyInviteMyhomeNoti = new();
+        message.ReplyInviteMyhomeNoti.AcceptOrRefuse = replyValue;
+        message.ReplyInviteMyhomeNoti.ReceiverId = invitor_cache.UserGuid;
+        message.ReplyInviteMyhomeNoti.ReplyUserGuid = myGuid;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null !!!");
+
+        rabbit_mq.SendMessage(invitor_cache.CurrentServer, message);
+
+        return true;
+    }
+    
+}
+
+

GameServer/Contents/Friend/PacketHandler/ReplyReceivedFriendRequestPacketHandler.cs

@@ -0,0 +1,107 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.ReplyReceivedFriendRequestReq), typeof(ReplyReceivedFriendRequestPacketHandler), typeof(GameLoginListener))]
+public class ReplyReceivedFriendRequestPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.ReplyReceivedFriendRequestReq;
+        var target_guid = request.TargetGuid;
+        var reply_type = request.AcceptOrRefuse;
+
+        var result = await replyReceivedFriendReq(owner, target_guid, reply_type);
+        if (result.isFail())
+        {
+            send_GS2C_ACK_REPLY_RECEIVED_FRIEND_REQUEST(owner, result);
+            return result;
+        }
+
+        //로직처리 성공시
+        send_GS2C_ACK_REPLY_RECEIVED_FRIEND_REQUEST(owner, result, target_guid);
+
+        await send_GS2CS_NTF_FRIEND_ACCEPT(owner, target_guid, reply_type);
+
+        if (reply_type == (int)FriendRequestReplyType.Accept)
+        {
+            await QuestManager.It.QuestCheck(owner, new QuestFriend(EQuestEventTargetType.FRIEND, EQuestEventNameType.ADDED));
+            
+            Thread.Sleep(1000);
+            await owner.send_GS2CS_NTF_STATE_TO_FRIEND(target_guid);
+        }
+
+        return result;
+    }
+
+    private async Task<Result> replyReceivedFriendReq(Player owner, string targetGuid, Int32 replyType)
+    {
+        //replyType : Accept = 1,         //수락
+        //replyType : Refuse = 2,         //거절
+        IFriendInterlockAction interlock_actioin = new ReplyFriendRequestLockAction(owner, owner.getUserGuid(), targetGuid, replyType);
+        var result = await interlock_actioin.doInterlockAction();
+
+        return result;
+    }
+
+    private static async Task<bool> send_GS2CS_NTF_FRIEND_ACCEPT(Player owner, string targetGuid, Int32 replyType)
+    {
+        ServerMessage acceptNoti = new ServerMessage();
+        acceptNoti.FriendAcceptNoti = new();
+        acceptNoti.FriendAcceptNoti.SenderId = owner.getAccountId();
+        acceptNoti.FriendAcceptNoti.SenderGuid = owner.getUserGuid();
+        acceptNoti.FriendAcceptNoti.SenderNickName = owner.getUserNickname();
+        acceptNoti.FriendAcceptNoti.AcceptOrRefuse = replyType;
+        acceptNoti.FriendAcceptNoti.ReceiverId = "";
+        acceptNoti.FriendAcceptNoti.ReceiverGuid = targetGuid;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var login_cache_request = new LoginCacheOtherUserRequest(owner, server_logic.getRedisConnector(), targetGuid);
+        var result = await login_cache_request.fetchLogin();
+        if (result.isSuccess())
+        {
+            var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMQ4Game;
+            NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null !!!");
+
+            var login_cache = login_cache_request.getLoginCache();
+            NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null !!!");
+            rabbit_mq.SendMessage(login_cache.CurrentServer, acceptNoti);
+        }
+        return true;
+    }
+
+
+    private static bool send_GS2C_ACK_REPLY_RECEIVED_FRIEND_REQUEST(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) { return false; }
+        return true;
+    }
+
+
+    private static bool send_GS2C_ACK_REPLY_RECEIVED_FRIEND_REQUEST(Player owner, Result result, string guid)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.ReplyReceivedFriendRequestRes = new();
+        ack_packet.Response.ReplyReceivedFriendRequestRes.Guid = guid;
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) { return false; }
+        return true;
+    }
+}

GameServer/Contents/Friend/PacketHandler/SendFriendRequestPacketHandler.cs

@@ -0,0 +1,131 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.SendFriendRequestReq), typeof(SendFriendRequestPacketHandler), typeof(GameLoginListener))]
+public class SendFriendRequestPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var owner = session as Player;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+        var recv_msg = recvMessage as ClientToGame;
+        NullReferenceCheckHelper.throwIfNull(recv_msg, () => $"recv_msg is null !!!");
+        var request = recv_msg.Request.SendFriendRequestReq;
+        var nickname = request.NickName;
+
+        var friend_agent_action = owner.getEntityAction<FriendAgentAction>();
+
+        //닉네임 없으면 존재하지 않는 캐릭터
+        (var result, var nickname_attrib) = await NicknameHelper.findNickname(nickname);
+        if (result.isFail())
+        {
+            Log.getLogger().error($"SendFriendRequestReq nickname not found. nickname : {nickname}");
+            result.setFail(ServerErrorCode.FriendRequestNotExistInfo);
+            send_GS2C_ACK_SEND_FRIEND_REQUEST(owner, result);
+            
+            return result;
+        }
+
+        NullReferenceCheckHelper.throwIfNull(nickname_attrib, () => $"nickname_attrib is null !!!");
+
+        var friend_guid = nickname_attrib.UserGuid;
+        var send_friend_request_action = owner.getEntityAction<SendFriendRequestAction>();
+        
+        result = await send_friend_request_action.addRequestToCache(nickname, friend_guid);
+        if(result.isFail())
+        {
+            //에러 패킷 리턴 
+            send_GS2C_ACK_SEND_FRIEND_REQUEST(owner, result);
+            return result;
+        }
+
+        var server_logic = GameServerApp.getServerLogic();
+        var friend_request_cache = new FriendReqCacheRequest(owner, owner.getUserGuid(), friend_guid, server_logic.getRedisConnector());
+
+        (result, var req) = await friend_agent_action.sendedRequestExistCheck(friend_request_cache, friend_guid);
+        if (result.isFail() || friend_request_cache is null)
+        {
+            send_GS2C_ACK_SEND_FRIEND_REQUEST(owner, result);
+            return result;
+        }
+
+        NullReferenceCheckHelper.throwIfNull(req, () => $"req is null !!!");
+
+        FriendRequestInfo info = new();
+        info.NickName = nickname;
+        info.Guid = req.m_receiver_guid;
+        info.IsNew = req.m_is_new;
+        info.RequestTime = Timestamp.FromDateTime(req.m_request_time);
+        send_GS2C_ACK_SEND_FRIEND_REQUEST(owner, result, info);
+
+        await send_GS2CS_NTF_FRIEND_REQUEST(owner, info);
+
+        //Log
+        List<ILogInvoker> invokers = new List<ILogInvoker>();
+        invokers.Add(new SendFriendRequestBusinessLog(owner.getUserGuid(), friend_guid));
+        var log_action = new LogActionEx(LogActionType.SendFriendRequest);
+        BusinessLogger.collectLogs(log_action, owner, invokers);
+
+
+        await QuestManager.It.QuestCheck(owner, new QuestFriend(EQuestEventTargetType.FRIEND, EQuestEventNameType.REQUESTED));
+
+        return result;
+    }
+
+    private static async Task<bool> send_GS2CS_NTF_FRIEND_REQUEST(Player owner, FriendRequestInfo info)
+    {
+        var message = new ServerMessage();
+        message.FriendRequestNoti = new();
+        message.FriendRequestNoti.RequestInfo = new();
+        message.FriendRequestNoti.RequestInfo.Guid = info.Guid;
+        message.FriendRequestNoti.RequestInfo.NickName = info.NickName;
+        message.FriendRequestNoti.RequestInfo.RequestTime = info.RequestTime;
+        message.FriendRequestNoti.RequestInfo.IsNew = info.IsNew;
+
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbit_mq = server_logic.getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null !!!");
+        var login_cache_request = new LoginCacheOtherUserRequest(owner, server_logic.getRedisConnector(), info.Guid);
+        var result = await login_cache_request.fetchLogin();
+        if (result.isSuccess())
+        {
+            var login_cache = login_cache_request.getLoginCache();
+            NullReferenceCheckHelper.throwIfNull(login_cache, () => $"login_cache is null !!!");
+            rabbit_mq.SendMessage(login_cache.CurrentServer, message);
+        }
+
+        return true;
+    }
+
+    private static bool send_GS2C_ACK_SEND_FRIEND_REQUEST(Player owner, Result result)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.SendFriendRequestRes = new();
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) { return false; }
+        return true;
+    }
+
+
+    private static bool send_GS2C_ACK_SEND_FRIEND_REQUEST(Player owner, Result result, FriendRequestInfo info)
+    {
+        var ack_packet = new ClientToGame();
+        ack_packet.Response = new ClientToGameRes();
+        ack_packet.Response.ErrorCode = result.ErrorCode;
+        ack_packet.Response.SendFriendRequestRes = new();
+        ack_packet.Response.SendFriendRequestRes.FriendRequestInfo = info;
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(owner, ack_packet)) { return false; }
+        return true;
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendDeleteHandler.cs

@@ -0,0 +1,42 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class NotifyFriendDeleteHandler
+{
+    public void send_GS2C_NTF_FRIEND_DELETE(ServerMessage.Types.FriendDeleteNoti noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.ReceiverGuid, out var player))
+        {
+            Log.getLogger().warn($"{noti.SenderGuid} user not exist this Server");
+            return;
+        }
+
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.FriendDeleteNoti = new();
+        clientToGame.Message.FriendDeleteNoti.SenderId = noti.SenderId;
+        clientToGame.Message.FriendDeleteNoti.SenderGuid = noti.SenderGuid;
+        clientToGame.Message.FriendDeleteNoti.SenderNickName = noti.SenderNickName;
+        clientToGame.Message.FriendDeleteNoti.ReceiverId = noti.ReceiverId;
+        clientToGame.Message.FriendDeleteNoti.ReceiverGuid = noti.ReceiverGuid;
+        
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+
+        QuestManager.It.QuestCheck(player, new QuestFriend(EQuestEventTargetType.FRIEND, EQuestEventNameType.DELETED)).Wait();
+
+    }
+    
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendLeavingHomeHandler.cs

@@ -0,0 +1,38 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+
+public class NotifyFriendLeavingHomeHandler
+{
+    public void send_GS2C_NTF_FRIEND_LEAVING_HOME(ServerMessage.Types.GS2C_NTF_FRIEND_LEAVING_HOME noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        // ReceiverID에 friendGuid가 있다.
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.ReceiverId, out var player))
+        {
+            Log.getLogger().warn($"{noti.Guid} user not exist this Server");
+            return;
+        }
+
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.NtfFriendLeavingHome = new();
+        clientToGame.Message.NtfFriendLeavingHome.Guid = noti.Guid;
+        clientToGame.Message.NtfFriendLeavingHome.NickName = noti.NickName;
+        
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendLoginHandler.cs

@@ -0,0 +1,36 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class NotifyFriendLoginHandler
+{
+    public void send_GS2C_NTF_LOGIN_TO_FRIEND(Player player, ServerMessage.Types.LoginNotiToFriend noti)
+    {
+        ClientToGame ntf_friend_login = new ClientToGame();
+        ntf_friend_login.Message = new ClientToGameMessage();
+        ntf_friend_login.Message.FriendLoginNoti = new();
+        ntf_friend_login.Message.FriendLoginNoti.BaseInfo = new();
+        ntf_friend_login.Message.FriendLoginNoti.BaseInfo.SenderId = noti.BaseInfo.SenderId;
+        ntf_friend_login.Message.FriendLoginNoti.BaseInfo.SenderGuid = noti.BaseInfo.SenderGuid;
+        ntf_friend_login.Message.FriendLoginNoti.BaseInfo.SenderNickName = noti.BaseInfo.SenderNickName;
+        ntf_friend_login.Message.FriendLoginNoti.BaseInfo.SenderState = noti.BaseInfo.SenderState;
+        ntf_friend_login.Message.FriendLoginNoti.BaseInfo.SenderMapId = noti.BaseInfo.SenderMapId;
+        ntf_friend_login.Message.FriendLoginNoti.LocationInfo = noti.LocationInfo;
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(player, ntf_friend_login))
+        {
+            Log.getLogger().error("Failed to send_GS2C_NTF_LOGIN_TO_FRIEND !!!");
+        }
+
+        
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendLogoutHandler.cs

@@ -0,0 +1,39 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class NotifyFriendLogoutHandler
+{
+    public void send_GS2C_NTF_FRIEND_LOGOUT(ServerMessage.Types.LogoutNotiToFriend noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.BaseInfo.ReceiverGuid, out var player))
+        {
+            Log.getLogger().warn($"{noti.BaseInfo.SenderGuid} user not exist this Server");
+            return;
+        }
+
+        
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.FriendLogoutNoti = new();
+        clientToGame.Message.FriendLogoutNoti.BaseInfo = new();
+        clientToGame.Message.FriendLogoutNoti.BaseInfo.SenderId = noti.BaseInfo.SenderId;
+        clientToGame.Message.FriendLogoutNoti.BaseInfo.SenderGuid = noti.BaseInfo.SenderGuid;
+        clientToGame.Message.FriendLogoutNoti.BaseInfo.SenderNickName = noti.BaseInfo.SenderNickName;
+        clientToGame.Message.FriendLogoutNoti.BaseInfo.ReceiverId = noti.BaseInfo.ReceiverId;
+
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendRequestCancelHandler.cs

@@ -0,0 +1,40 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class NotifyFriendRequestCancelHandler
+{
+
+    public void send_GS2C_NTF_FRIEND_REQUEST_CANCEL(ServerMessage.Types.CancelFriendRequestNoti noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.ReceiverGuid, out var player))
+        {
+            Log.getLogger().warn($"{noti.ReceiverGuid} user not exist this Server");
+            return;
+        }
+        
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.CancelFriendRequestNoti = new();
+        clientToGame.Message.CancelFriendRequestNoti.SenderId = noti.SenderId;
+        clientToGame.Message.CancelFriendRequestNoti.SenderGuid = noti.SenderGuid;
+        clientToGame.Message.CancelFriendRequestNoti.SenderNickName = noti.SenderNickName;
+        clientToGame.Message.CancelFriendRequestNoti.ReceiverId = noti.ReceiverId;
+        clientToGame.Message.CancelFriendRequestNoti.ReceiverGuid = noti.ReceiverGuid;
+
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendRequestHandler.cs

@@ -0,0 +1,39 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+
+
+namespace GameServer;
+
+public class NotifyFriendRequestHandler
+{
+    public void send_GS2C_NTF_FRIEND_REQUEST(ServerMessage.Types.FriendRequestNoti noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.RequestInfo.Guid, out var player))
+        {
+            Log.getLogger().warn($"{noti.RequestInfo.Guid} user not exist this Server");
+            return;
+        }
+
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.FriendRequestNoti = new();
+        clientToGame.Message.FriendRequestNoti.RequestInfo = new();
+        clientToGame.Message.FriendRequestNoti.RequestInfo.Guid = noti.RequestInfo.Guid;
+        clientToGame.Message.FriendRequestNoti.RequestInfo.NickName = noti.RequestInfo.NickName;
+        clientToGame.Message.FriendRequestNoti.RequestInfo.IsNew = noti.RequestInfo.IsNew;
+        clientToGame.Message.FriendRequestNoti.RequestInfo.RequestTime = noti.RequestInfo.RequestTime;
+
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+    }
+
+
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyFriendStateHandler.cs

@@ -0,0 +1,47 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class NotifyFriendStateHandler
+{
+    public bool send_GS2C_NTF_FRIEND_STATE(ServerMessage.Types.StateNotiToFriend noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.BaseInfo.ReceiverGuid, out var player))
+        {
+            Log.getLogger().error($"send_GS2CS_NTF_FRIEND_STATE {noti.BaseInfo.ReceiverGuid} user not exist this Server");
+            return false;
+        }
+
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.FriendStateNoti = new();
+        clientToGame.Message.FriendStateNoti.BaseInfo = new();
+        clientToGame.Message.FriendStateNoti.BaseInfo.SenderId = noti.BaseInfo.SenderId;
+        clientToGame.Message.FriendStateNoti.BaseInfo.SenderGuid = noti.BaseInfo.SenderGuid;
+        clientToGame.Message.FriendStateNoti.BaseInfo.SenderNickName = noti.BaseInfo.SenderNickName;
+        clientToGame.Message.FriendStateNoti.BaseInfo.SenderState = noti.BaseInfo.SenderState;
+        clientToGame.Message.FriendStateNoti.BaseInfo.SenderMapId = noti.BaseInfo.SenderMapId;
+        clientToGame.Message.FriendStateNoti.LocationInfo = noti.LocationInfo;
+
+        if (false == GameServerApp.getServerLogic().onSendPacket(player, clientToGame))
+        { 
+            Log.getLogger().error("Failed to send_GS2C_NTF_FRIEND_STATE !!!");
+        }
+        
+        
+        return true;
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyReceiveInviteMyHomeHandler.cs

@@ -0,0 +1,45 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer;
+
+public class NotifyReceiveInviteMyHomeHandler
+{
+    public void send_GS2C_NTF_RECEIVE_INVITE_MYHOME(ServerMessage.Types.ReceiveInviteMyHomeNoti noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.BaseInfo.ReceiverGuid, out var player))
+        {
+            Log.getLogger().warn($"{noti.BaseInfo.SenderGuid} user not exist this Server");
+            return;
+        }
+
+        ClientToGame clientToGame = new();
+        clientToGame.Message = new();
+        clientToGame.Message.ReceiveInviteMyHomeNoti = new();
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo = new();
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.SenderMapId = 0;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.SenderNickName = noti.BaseInfo.SenderNickName;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.SenderGuid = noti.BaseInfo.SenderGuid;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.SenderId = noti.BaseInfo.SenderId;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.ReceiverGuid = noti.BaseInfo.ReceiverGuid;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.ReceiverNickName = noti.BaseInfo.ReceiverNickName;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.BaseInfo.ReceiverId = noti.BaseInfo.ReceiverId;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.ExpireTime = noti.ExpireTime;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.InviterMyHomeId = noti.InviterMyHomeId;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.ReplyExpireTime = noti.ReplyExpireTime;
+        clientToGame.Message.ReceiveInviteMyHomeNoti.UniqueKey = noti.UniqueKey;
+
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+    }
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyReplyFriendRequestHandler.cs

@@ -0,0 +1,32 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class NotifyReplyFriendRequestHandler
+{
+    public void send_GS2C_NTF_FRIEND_ACCEPT(Player player, ServerMessage.Types.FriendAcceptNoti noti)
+    {
+        ClientToGame clientToGame = new ClientToGame();
+        clientToGame.Message = new ClientToGameMessage();
+        clientToGame.Message.FriendAcceptNoti = new ClientToGameMessage.Types.FriendAcceptNoti();
+        clientToGame.Message.FriendAcceptNoti.AcceptOrRefuse = noti.AcceptOrRefuse;
+        clientToGame.Message.FriendAcceptNoti.SenderId = noti.SenderId;
+        clientToGame.Message.FriendAcceptNoti.SenderGuid = noti.SenderGuid;
+        clientToGame.Message.FriendAcceptNoti.SenderNickName = noti.SenderNickName;
+        clientToGame.Message.FriendAcceptNoti.ReceiverId = noti.ReceiverId;
+        clientToGame.Message.FriendAcceptNoti.ReceiverGuid = noti.ReceiverGuid;
+
+        GameServerApp.getServerLogic().onSendPacket(player, clientToGame);
+    }
+
+}

GameServer/Contents/Friend/RabbitMessageHandler/NotifyReplyInviteFriendHandler.cs

@@ -0,0 +1,41 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer;
+
+public class NotifyReplyInviteFriendHandler
+{
+    public void send_GS2C_NTF_REPLY_INVITE_MYHOME(ServerMessage.Types.ReplyInviteMyhomeNoti noti)
+    {
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        /*
+            ReceiverID로 찾는 이유 
+            리팩토링 전에 id로 찾던게 있어서 noti 보낼때 id에 guid로 담아서 보낸다.
+         */
+        if (false == player_manager.tryGetUserByPrimaryKey(noti.ReceiverId, out var player))
+        {
+            Log.getLogger().warn($"{noti.ReplyUserGuid} user not exist this Server");
+            return;
+        }
+        ClientToGame noti_packet = new ClientToGame();
+        noti_packet.Message = new ClientToGameMessage();
+        noti_packet.Message.ReplyInviteMyhomeNoti = new ();
+        noti_packet.Message.ReplyInviteMyhomeNoti.ReplyUserGuid = noti.ReplyUserGuid;
+        noti_packet.Message.ReplyInviteMyhomeNoti.ReceiverId = noti.ReceiverId;
+        noti_packet.Message.ReplyInviteMyhomeNoti.AcceptOrRefuse = noti.AcceptOrRefuse;
+
+        GameServerApp.getServerLogic().onSendPacket(player, noti_packet);
+    }
+}
+