초기커밋

GameServer/Contents/Claim/Action/ClaimAction.cs

@@ -0,0 +1,592 @@
+using Amazon.S3.Model;
+using Google.Protobuf.WellKnownTypes;
+using RabbitMQ.Client;
+using ServerCommon;
+using ServerCore; using ServerBase;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Security.Claims;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GameServer
+{
+    public class ClaimAction : EntityActionBase
+    {
+        private ConcurrentDictionary<Int32, ServerCommon.Claim> m_normal_claim { get; set; } = new();
+        private ConcurrentDictionary<Int32, ServerCommon.Claim> m_membership_claim { get; set; } = new();
+
+        private bool m_data_load = false;
+        
+        public ClaimAction(EntityBase owner) : base(owner)
+        {
+        }
+
+        public override Task<Result> onInit()
+        {
+            var result = new Result();
+            return Task.FromResult(result);
+        }
+
+
+        public void setDataLoad(bool isLoad)
+        {
+            m_data_load = isLoad;
+        }
+        public bool getDataLoad()
+        {
+            return m_data_load;
+        }
+        
+
+        public Result setClaimFromDoc(ClaimDoc doc)
+        {
+            var result = new Result();
+            var owner = getOwner();
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            EntityBase claim;
+
+            var claim_attrib = doc.getAttrib<ClaimAttrib>();
+            NullReferenceCheckHelper.throwIfNull(claim_attrib, () => $"claim_attrib is null !!!");
+            claim = new ServerCommon.Claim(owner, claim_attrib.ClaimType);
+
+            var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
+            NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
+
+            if (false == doc.getAttribWrappers().TryGetValue(typeof(ClaimAttrib), out var to_copy_doc_attrib))
+            {
+                var err_msg = $"Fail to get ClaimAttrib";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+            var attrib_base = to_copy_doc_attrib.getAttribBase();
+            var doc_attrib = attrib_base as ClaimAttrib;
+            if (doc_attrib is null)
+            {
+                var err_msg = $"Fail to get ClaimAttrib";
+                result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
+                return result;
+            }
+
+            claim_attribute.ClaimType = doc_attrib.ClaimType;
+            claim_attribute.ActiveRewardIdx = doc_attrib.ActiveRewardIdx;
+            claim_attribute.ActiveTime = doc_attrib.ActiveTime;
+            claim_attribute.CreateTime = doc_attrib.CreateTime;
+            claim_attribute.CompleteTime = doc_attrib.CompleteTime;
+            claim_attribute.IsComplete = doc_attrib.IsComplete;
+
+            claim_attribute.syncOriginDocBaseWithNewDoc<ClaimAttribute>(doc);
+            
+            Int32 claim_id = claim_attribute.ClaimId = doc_attrib.ClaimId;
+
+            var casted_claim = claim as ServerCommon.Claim;
+            NullReferenceCheckHelper.throwIfNull(casted_claim, () => $"casted_claim is null !!!");
+            if (claim_attrib.ClaimType == MetaAssets.ClaimType.Normal)
+            {
+                m_normal_claim.TryAdd(claim_id, casted_claim);
+            }
+            else
+            {
+                m_membership_claim.TryAdd(claim_id, casted_claim);
+            }
+            return result;
+        }
+        public async Task<(Result, List<ClaimMetaData>, List<Int32>)> update()
+        {
+            var result = new Result();
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            (var acceptable_claims, var old_claims) = getUpdatableClaims();
+            if (acceptable_claims.Count == 0 && old_claims.Count == 0) return (result, new(), new());
+
+            result = await owner.runTransactionRunnerSafelyWithTransGuid( owner.getUserGuid()
+                                                                        , TransactionIdType.PrivateContents, "ClaimUpdate", delegateUpdateClaim);
+            if (result.isFail())
+            {
+                string err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()} - {owner.toBasicString()}";
+                Log.getLogger().error(err_msg);
+                return (result, new(), new());
+            }
+            return (result, acceptable_claims, old_claims);
+
+            async Task<Result> delegateUpdateClaim() => await updateClaim(owner, acceptable_claims, old_claims);
+
+        }
+
+        public (List<ClaimMetaData>, List<Int32>) getUpdatableClaims()
+        {
+            var acceptable_claims = getAcceptableClaims();
+            var old_claims = getOldClaim();
+            return (acceptable_claims, old_claims);
+        }
+
+        public static List<ClaimMetaData> getOldClaims()
+        {
+            List<ClaimMetaData> rets = new();
+            DateTime nowDt = DateTimeHelper.Current;
+
+            foreach (ClaimMetaData metaData in MetaData.Instance._ClaimMetaTable.Values)
+            {
+                if (metaData.EndTime < nowDt)
+                {
+                    rets.Add(metaData);
+                }
+            }
+            return rets;
+        }
+
+        private async Task<Result> updateClaim(Player owner, List<ClaimMetaData> acceptableClaim, List<Int32> oldClaim)
+        {
+            (var result, var new_claims) = updateClaims(acceptableClaim, oldClaim);
+            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())
+            {
+                return result;
+            }
+
+            foreach (var new_claim in new_claims)
+            {
+                var claim_attribute = new_claim.getEntityAttribute<ClaimAttribute>();
+                NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
+
+                if (claim_attribute.ClaimType == MetaAssets.ClaimType.Normal)
+                {
+                    m_normal_claim.TryAdd(claim_attribute.ClaimId, new_claim as ServerCommon.Claim);
+                }
+                else
+                {
+                    m_membership_claim.TryAdd(claim_attribute.ClaimId, new_claim as ServerCommon.Claim);
+                }
+            }
+
+            foreach (var old_claim in oldClaim)
+            {
+                m_normal_claim.TryRemove(old_claim, out _);
+                m_membership_claim.TryRemove(old_claim, out _);
+            }
+            
+            return result;
+        }
+
+        private (Result, List<ServerCommon.Claim>) updateClaims(List<ClaimMetaData> acceptable_claims, List<Int32> oldClaims)
+        {
+            var result = new Result();
+
+            DateTime now = DateTimeHelper.Current;
+            List<ServerCommon.Claim> claims = new();
+
+            foreach (var meta in acceptable_claims)
+            {
+                var claim_id = meta.ClaimId;
+                var claim_type = meta.ClaimType;
+
+                if (claim_type == MetaAssets.ClaimType.Normal)
+                {
+                    if (m_normal_claim.ContainsKey(claim_id)) continue;
+                }
+                else
+                {
+                    if (m_membership_claim.ContainsKey(claim_id)) continue;
+                }
+
+                var new_claim = makeNewClaim(now, meta);
+                claims.Add(new_claim);
+                //m_normal_claim.TryAdd(claim_id, normal_claim);
+            }
+
+            foreach (var old_claim in oldClaims)
+            {
+                if (false == m_normal_claim.TryGetValue(old_claim, out var normal_claim)) continue;
+                NullReferenceCheckHelper.throwIfNull(normal_claim, () => $"normal_claim is null !!!");
+                var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
+                NullReferenceCheckHelper.throwIfNull(normal_claim_attribute, () => $"normal_claim_attribute is null !!!");
+                normal_claim_attribute.deleteEntityAttribute();
+            }
+            foreach (var old_claim in oldClaims)
+            {
+                if (false == m_membership_claim.TryGetValue(old_claim, out var membership_claim)) continue;
+                NullReferenceCheckHelper.throwIfNull(membership_claim, () => $"membership_claim is null !!!");
+                var membership_claim_attribute = membership_claim.getEntityAttribute<ClaimAttribute>();
+                NullReferenceCheckHelper.throwIfNull(membership_claim_attribute, () => $"membership_claim_attribute is null !!!");
+                membership_claim_attribute.deleteEntityAttribute();
+            }
+
+            return (result, claims);
+        }
+
+        private ServerCommon.Claim resetClaim(ServerCommon.Claim claim, ClaimMetaData metaData)
+        {
+            var owner = getOwner() as Player;
+
+            DateTime now = DateTimeHelper.Current;
+            var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
+            NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
+            claim_attribute.ActiveRewardIdx = metaData.DetailInfo.First().Value.Idx;
+            claim_attribute.ActiveTime = now;
+            claim_attribute.CreateTime = now;
+            claim_attribute.CompleteTime = now;
+            claim_attribute.IsComplete = 0;
+            claim_attribute.modifiedEntityAttribute();
+
+            return claim;
+        }
+
+        private ServerCommon.Claim updateClaimRewardable(ServerCommon.Claim claim, ClaimMetaData metaData)
+        {
+            var owner = getOwner() as Player;
+
+            DateTime now = DateTimeHelper.Current;
+            
+            var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
+            NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
+            claim_attribute.ActiveTime = now.AddSeconds(-86400);
+            claim_attribute.modifiedEntityAttribute();
+
+            return claim;
+        }
+
+        private ServerCommon.Claim makeNewClaim(DateTime now, ClaimMetaData metaData)
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            var claim = new ServerCommon.Claim(getOwner(), metaData.ClaimType);
+
+            var claim_attribute = claim.getEntityAttribute<ClaimAttribute>();
+            NullReferenceCheckHelper.throwIfNull(claim_attribute, () => $"claim_attribute is null !!!");
+            
+            claim_attribute.ClaimId = metaData.ClaimId;
+            claim_attribute.ClaimType = metaData.ClaimType;
+            claim_attribute.ActiveRewardIdx = metaData.DetailInfo.First().Value.Idx;
+            claim_attribute.ActiveTime = now;
+            claim_attribute.CreateTime = now;
+            claim_attribute.CompleteTime = now;
+            claim_attribute.IsComplete = 0;
+
+            var new_claim_doc = new ClaimDoc(owner.getUserGuid(), metaData.ClaimType, metaData.ClaimId);
+            claim_attribute.syncOriginDocBaseWithNewDoc<ClaimAttribute>(new_claim_doc);
+            
+            var claim_attrib = new_claim_doc.getAttrib<ClaimAttrib>();
+            NullReferenceCheckHelper.throwIfNull(claim_attrib, () => $"claim_attrib is null !!!");
+            
+            claim_attrib.ClaimId = metaData.ClaimId;
+            claim_attrib.ClaimType = metaData.ClaimType;
+            claim_attrib.ActiveRewardIdx = metaData.DetailInfo.First().Value.Idx;
+            claim_attrib.ActiveTime = now;
+            claim_attrib.CreateTime = now;
+            claim_attrib.CompleteTime = now;
+            claim_attrib.IsComplete = 0;
+
+            claim_attribute.newEntityAttribute();
+
+            return claim;
+        }
+
+
+        private List<ClaimMetaData> getAcceptableClaims()
+        {
+            var owner = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+            List<ClaimMetaData> rets = new();
+
+            var current_metas = ClaimRewardHelper.getCurrentClaims();
+
+            foreach (var metaData in current_metas)
+            {
+                var claim_id = metaData.GetMetaId();
+                if (m_normal_claim.ContainsKey(claim_id)) continue;
+                rets.Add(metaData);
+            }
+            return rets;
+        }
+
+        public List<Int32> getOldClaim()
+        {
+            List<ClaimMetaData> old_metas = getOldClaims();
+            List<Int32> old_claims = new();
+            
+            foreach (var meta in old_metas)
+            {
+                var claim_id = meta.ClaimId;
+                if (m_normal_claim.ContainsKey(claim_id))
+                {
+                    old_claims.Add(claim_id);
+                }
+            }
+            
+            return old_claims;
+        }
+
+
+        public async Task cheatClaimReset() 
+        { 
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+
+            var result = new Result();
+
+
+            var fn_reset_claim = async delegate ()
+            {
+                var result = new Result();
+                var err_msg = string.Empty;
+
+                List<ILogInvoker> log_invokers = new();
+
+                foreach (var normal_claim in m_normal_claim.Values)
+                {
+                    var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
+                    NullReferenceCheckHelper.throwIfNull(normal_claim_attribute, () => $"normal_claim_attribute is null !!!");
+                    var claim_id = normal_claim_attribute.ClaimId;
+                    (result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Normal);
+                    if (result.isFail())continue;
+                    NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
+                    resetClaim(normal_claim, claim_meta);
+
+                    var log_invoker = new CheatClaimResetBusinessLog(MetaAssets.ClaimType.Normal, claim_id, normal_claim_attribute.ActiveRewardIdx);
+                    log_invokers.Add(log_invoker);
+                }
+
+                foreach (var membership_claim in m_membership_claim.Values)
+                {
+                    var membership_claim_attribute = membership_claim.getEntityAttribute<ClaimAttribute>();
+                    NullReferenceCheckHelper.throwIfNull(membership_claim_attribute, () => $"normal_claim_attribute is null !!!");
+                    var claim_id = membership_claim_attribute.ClaimId;
+                    (result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Membership);
+                    if (result.isFail()) continue;
+                    NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
+                    resetClaim(membership_claim, claim_meta);
+
+                    var log_invoker = new CheatClaimResetBusinessLog(MetaAssets.ClaimType.Membership, claim_id, membership_claim_attribute.ActiveRewardIdx);
+                    log_invokers.Add(log_invoker);
+                }
+
+                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandClaimReset, server_logic.getDynamoDbClient());
+                {
+                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+                }
+                result = await QueryHelper.sendQueryAndBusinessLog(batch);
+                if (result.isFail())
+                {
+                    return result;
+                }
+
+                
+                foreach (var normal_claim in m_normal_claim.Values)
+                {
+                    var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
+                    if (normal_claim_attribute is null) continue;
+
+                    var claim_id = normal_claim_attribute.ClaimId;
+
+                }
+                send_GS2C_NTF_CLAIM_UPDATE();
+
+                return result;
+            };
+
+            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CheatResetClaim", fn_reset_claim);
+            if (result.isFail())
+            {
+                var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
+                Log.getLogger().error(err_msg);
+                return;
+            }
+        }
+
+
+
+        public async Task cheatClaimUpdateRewardable()
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"server_logic is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+
+            var result = new Result();
+
+            var fn_claim_update_rewardable = async delegate ()
+            {
+                var result = new Result();
+                var err_msg = string.Empty;
+
+                List<ILogInvoker> log_invokers = new();
+                foreach (var normal_claim in m_normal_claim.Values)
+                {
+                    var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
+                    if (normal_claim_attribute is null) continue;
+                    var claim_id = normal_claim_attribute.ClaimId;
+                    (result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Normal);
+                    if (result.isFail()) continue;
+                    NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
+                    updateClaimRewardable(normal_claim, claim_meta);
+                    
+                    var log_invoker = new CheatClaimRewardableBusinessLog(MetaAssets.ClaimType.Normal, claim_id, normal_claim_attribute.ActiveRewardIdx);
+                    log_invokers.Add(log_invoker);
+                }
+
+                foreach (var membership_claim in m_membership_claim.Values)
+                {
+                    var membership_claim_attribute = membership_claim.getEntityAttribute<ClaimAttribute>();
+                    if (membership_claim_attribute is null) continue;
+                    var claim_id = membership_claim_attribute.ClaimId;
+                    (result, var claim_meta) = ClaimRewardHelper.getClaimMeta(claim_id, MetaAssets.ClaimType.Membership);
+                    if (result.isFail()) continue;
+                    NullReferenceCheckHelper.throwIfNull(claim_meta, () => $"claim_meta is null !!!");
+                    updateClaimRewardable(membership_claim, claim_meta);
+                    var log_invoker = new CheatClaimRewardableBusinessLog(MetaAssets.ClaimType.Membership, claim_id, membership_claim_attribute.ActiveRewardIdx);
+                    log_invokers.Add(log_invoker);
+                }
+
+                var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandClaimUpdate, server_logic.getDynamoDbClient());
+                {
+                    batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
+                }
+                batch.appendBusinessLogs(log_invokers);
+                
+                result = await QueryHelper.sendQueryAndBusinessLog(batch);
+                if (result.isFail())
+                {
+                    return result;
+                }
+
+                foreach (var normal_claim in m_normal_claim.Values)
+                {
+                    var normal_claim_attribute = normal_claim.getEntityAttribute<ClaimAttribute>();
+                    if(normal_claim_attribute is null) continue;
+                    var claim_id = normal_claim_attribute.ClaimId;
+
+                }
+                send_GS2C_NTF_CLAIM_UPDATE();
+
+                return result;
+            };
+
+            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CheatClaimUpdateRewardable", fn_claim_update_rewardable);
+            if (result.isFail())
+            {
+                var err_msg = $"Failed to runTransactionRunnerSafely() !!! : {result.toBasicString()} - {player.toBasicString()}";
+                Log.getLogger().error(err_msg);
+                return;
+            }
+
+        }
+
+        public ConcurrentDictionary<Int32, ServerCommon.Claim> getClaims(MetaAssets.ClaimType type)
+        {
+            if (type == MetaAssets.ClaimType.Normal)
+            {
+
+                return m_normal_claim;
+            }
+            else
+            {
+                return m_membership_claim;
+            }
+        }
+
+        public Result getClaim(Int32 claimId, MetaAssets.ClaimType type, [MaybeNullWhen(false)] out ServerCommon.Claim? claim)
+        {
+            var result = new Result();
+            if (type == MetaAssets.ClaimType.Normal)
+            {
+
+                result = getNormalClaim(claimId, out claim);
+            }
+            else
+            {
+                result = getMembershipClaim(claimId, out claim);
+            }
+
+            return result;
+        }
+
+        public ConcurrentDictionary<Int32, ServerCommon.Claim> getNormalClaims()
+        {
+            return m_normal_claim;
+        }
+
+        public Result getNormalClaim(Int32 claimId, [MaybeNullWhen(false)] out ServerCommon.Claim? claim)
+        {
+            var result = new Result();
+            if (false == m_normal_claim.TryGetValue(claimId, out claim))
+            { 
+                var err_msg = $"m_normal_claim claimId : {claimId} not exist, {getOwner().toBasicString()}";
+                result.setFail(ServerErrorCode.ClaimInfoNotExist, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+            NullReferenceCheckHelper.throwIfNull(claim, () => $"claim is null !!!");
+            return result;
+        }
+
+        public ConcurrentDictionary<Int32, ServerCommon.Claim> getMembershipClaims()
+        {
+            return m_membership_claim;
+        }
+
+        public Result getMembershipClaim(Int32 claimId, [MaybeNullWhen(false)] out ServerCommon.Claim? claim)
+        {
+            var result = new Result();
+            if (false == m_membership_claim.TryGetValue(claimId, out claim))
+            {
+                var err_msg = $"m_membership_claim claimId : {claimId} not exist, {getOwner().toBasicString()}";
+                result.setFail(ServerErrorCode.ClaimInfoNotExist, err_msg);
+                Log.getLogger().error(result.toBasicString());
+                return result;
+            }
+            NullReferenceCheckHelper.throwIfNull(claim, () => $"claim is null !!!");
+            return result;
+        }
+
+        public override void onClear()
+        {
+            return;
+        }
+
+        public void send_GS2C_NTF_CLAIM_UPDATE()
+        {
+            var player = getOwner() as Player;
+            NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
+
+            var server_logic = GameServerApp.getServerLogic();
+            NullReferenceCheckHelper.throwIfNull(server_logic, () => $"server_logic is null !!!");
+
+            var normal_claim_infos = ClaimRewardHelper.MakeClaimSendInfo(player, MetaAssets.ClaimType.Normal);
+            var membership_claim_infos = ClaimRewardHelper.MakeClaimSendInfo(player, MetaAssets.ClaimType.Membership);
+
+            foreach (var info in normal_claim_infos)
+            {
+                ClientToGame ntf_packet = new();
+                ntf_packet.Message = new();
+                ntf_packet.Message.ClaimUpdateNoti = new();
+                ntf_packet.Message.ClaimUpdateNoti.ClaimId = info.Key;
+                ntf_packet.Message.ClaimUpdateNoti.NormalInfo = info.Value;
+                ntf_packet.Message.ClaimUpdateNoti.MembershipInfo = membership_claim_infos.TryGetValue(info.Key, out var membership_info) ? membership_info : new();
+                if (false == server_logic.onSendPacket(player, ntf_packet))
+                {
+                    Log.getLogger().error($"SendPacket Fail");
+                    continue;
+                }
+            }
+        }
+    }
+
+}