초기커밋

ServerCommon/Cache/PartyInvitePartySendCacheRequest.cs

@@ -0,0 +1,236 @@
+using System.Globalization;
+
+
+using StackExchange.Redis;
+
+
+using ServerCore;
+using ServerBase;
+
+
+using USER_GUID = System.String;
+
+
+namespace ServerCommon;
+
+public class PartyInvitePartySendCache : CacheBase
+{
+    public Dictionary<string, DateTime> PartyInvitePartySends { get; set; } = new();
+    
+    public string toBasicString()
+    {
+        return $"PartyCache: PartyInvitePartySends:{PartyInvitePartySends}";
+    }
+}
+
+public class PartyInvitePartySendCacheRequest : RedisRequestSharedBase
+{
+    // in
+    private readonly string m_party_guid;
+    
+    // out
+    private PartyInvitePartySendCache? m_party_invite_party_send_cache_nullable { get; set; }
+
+    public PartyInvitePartySendCacheRequest(string party_guid, RedisConnector redisConnector) : base(party_guid,
+        redisConnector)
+    {
+        m_party_guid = party_guid;
+    }
+    
+    protected override string onMakeKey() => $"inviteparty:sendlist:{m_party_guid}";
+    public override string toBasicString() => $"PartyInvitePartySendCache: In:PartyGuid:{m_party_guid}, Out:{m_party_invite_party_send_cache_nullable?.toBasicString()}";
+
+    public async Task<Result> keepInvitePartySendCache()
+    {
+        var result = new Result();
+        string err_msg;
+
+        if (m_party_invite_party_send_cache_nullable == null || m_party_invite_party_send_cache_nullable.PartyInvitePartySends.Count <= 0) return result;
+        
+        try
+        {
+            result = await onPrepareRequest();
+            if (result.isFail()) return result;
+
+            var database = getDatabase();
+            ArgumentNullException.ThrowIfNull(database);
+
+            var redis_value = await database.KeyExpireAsync(getKey(), TimeSpan.FromMilliseconds(Constant.KEEP_PARTY_TIME));
+            if (false == redis_value)
+            {
+                err_msg = $"Failed to set expire PartyInvitePartySendCache in Redis !!! : Key:{getKey()} - {nameof(keepInvitePartySendCache)}";
+                result.setFail(ServerErrorCode.RedisGlobalPartyInvitePartySendCacheWriteFailed, err_msg);
+                Log.getLogger().error(err_msg);
+            }
+        }
+        catch (Exception e)
+        {
+            var error_code = ServerErrorCode.TryCatchException;
+            err_msg = $"Failed to set expire PartyInvitePartySendCache from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(keepInvitePartySendCache)}";
+            result.setFail(error_code, err_msg);
+            Log.getLogger().error(err_msg);
+        }
+
+        return result;
+    }
+    
+    public PartyInvitePartySendCache? getPartyInvitePartySendCache() => m_party_invite_party_send_cache_nullable;
+
+    public async Task<Result> fetchInvitePartySendCache()
+    {
+        var result = new Result();
+        string err_msg;
+
+        try
+        {
+            result = await onPrepareRequest();
+            if (result.isFail()) return result;
+
+            var database = getDatabase();
+            ArgumentNullException.ThrowIfNull(database);
+
+            var delete_time = DateTime.UtcNow.AddMilliseconds(-1 * Constant.KEEP_INVITEPARTY_TIME);
+            var curr_party_invite_party_sends = new Dictionary<string, DateTime>();
+            var delete_list = new List<string>();
+            
+            var redis_value = await database.HashGetAllAsync(getKey(), CommandFlags.PreferReplica);
+            foreach (var send_value in redis_value)
+            {
+                var send_time = send_value.Value.ToString().toUtcTime();
+                if (send_time < delete_time)
+                {
+                    delete_list.Add(send_value.Name.ToString());
+                    continue;
+                }
+                curr_party_invite_party_sends.Add(send_value.Name.ToString(), send_time);
+            }
+            
+            m_party_invite_party_send_cache_nullable ??= new PartyInvitePartySendCache();
+            m_party_invite_party_send_cache_nullable.PartyInvitePartySends.Clear();
+            foreach (var send in curr_party_invite_party_sends)
+            {
+                m_party_invite_party_send_cache_nullable.PartyInvitePartySends.Add(send.Key, send.Value);
+            }
+
+            result = await deleteInvitePartySendCache(delete_list); 
+            
+            return result;
+            
+        }
+        catch (Exception e)
+        {
+            var error_code = ServerErrorCode.TryCatchException;
+            err_msg = $"Failed to get PartyInvitePartySendCache from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(fetchInvitePartySendCache)}";
+            result.setFail(error_code, err_msg);
+            Log.getLogger().error(err_msg);
+        }
+
+        return result;
+    }
+
+    public async Task<List<string>?> organizeInvitePartySendCache()
+    {
+        if (null == m_party_invite_party_send_cache_nullable) return null;
+
+        var delete_time = DateTime.UtcNow.AddMilliseconds(-1 * Constant.KEEP_INVITEPARTY_TIME);
+        var delete_sends = (from send in m_party_invite_party_send_cache_nullable.PartyInvitePartySends where send.Value < delete_time select send.Key).ToList();
+        _ = await deleteInvitePartySendCache(delete_sends);
+
+        return delete_sends;
+    }
+    public async Task<Result> addInvitePartySendCache(IReadOnlyList<USER_GUID> add_user_guids)
+    {
+        var result = new Result();
+        string err_msg;
+
+        try
+        {
+            result = await onPrepareRequest();
+            if (result.isFail()) return result;
+
+            var database = getDatabase();
+            ArgumentNullException.ThrowIfNull(database);
+
+            foreach (var add_user in add_user_guids)
+            {
+                var invite_time = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture);
+                _ = await database.HashSetAsync(getKey(), add_user, invite_time);   
+            }
+
+            result = await keepInvitePartySendCache();
+        }
+        catch (Exception e)
+        {
+            var error_code = ServerErrorCode.TryCatchException;
+            err_msg = $"Failed to add party invite party send from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(addInvitePartySendCache)}";
+            result.setFail(error_code, err_msg);
+            Log.getLogger().error(err_msg);
+        }
+
+        return result;
+    }
+
+    public async Task<Result> deleteAllInvitePartySendCache()
+    {
+        var result = new Result();
+
+        try
+        {
+            result = await onPrepareRequest();
+            if (result.isFail()) return result;
+
+            var database = getDatabase();
+            ArgumentNullException.ThrowIfNull(database);
+
+            m_party_invite_party_send_cache_nullable = null;
+            _ = await database.KeyDeleteAsync(getKey(), CommandFlags.FireAndForget);
+                        
+            return result;
+            
+        }
+        catch (Exception e)
+        {
+            var error_code = ServerErrorCode.TryCatchException;
+            var err_msg = $"Failed to delete party invite party send from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(deleteAllInvitePartySendCache)}";
+            result.setFail(error_code, err_msg);
+            Log.getLogger().error(err_msg);
+        }
+
+        return result;
+    }
+    
+    public async Task<Result> deleteInvitePartySendCache(IReadOnlyList<string> delete_user_guids)
+    {
+        var result = new Result();
+        string err_msg;
+
+        try
+        {
+            result = await onPrepareRequest();
+            if (result.isFail()) return result;
+
+            var database = getDatabase();
+            ArgumentNullException.ThrowIfNull(database);
+
+            var delete_values = new List<RedisValue>(delete_user_guids.Select(x => new RedisValue(x)));
+            _ = await database.HashDeleteAsync(getKey(), delete_values.ToArray(), CommandFlags.PreferReplica);
+
+            foreach (var delete in delete_user_guids)
+            {
+                m_party_invite_party_send_cache_nullable?.PartyInvitePartySends.Remove(delete);
+            }
+                        
+            return result;
+            
+        }
+        catch (Exception e)
+        {
+            var error_code = ServerErrorCode.TryCatchException;
+            err_msg = $"Exception !!!, Failed to delete party invite party send from Redis !!! : : errorCode:{error_code}, exception:{e} - {nameof(deleteInvitePartySendCache)}";
+            result.setFail(error_code, err_msg);
+            Log.getLogger().error(err_msg);
+        }
+
+        return result;
+    }
+}