test complete

EVCB_OCPP.DBAPI/EVCB_OCPP.DBAPI.csproj

@@ -17,13 +17,14 @@
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.2" />
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.21.0" />
     <PackageReference Include="NLog.Web.AspNetCore" Version="5.3.14" />
+    <PackageReference Include="NRedisStack" Version="0.13.1" />
     <PackageReference Include="Quartz.Extensions.Hosting" Version="3.13.1" />
-    <PackageReference Include="ServiceStack.Redis" Version="8.4.0" />
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.10" />
   </ItemGroup>
 
   <ItemGroup>
     <Folder Include="DLL\" />
+    <Folder Include="Models\Redis\" />
   </ItemGroup>
 
   <ItemGroup>

EVCB_OCPP.DBAPI/Jobs/ServerMessageJob.cs

@@ -28,7 +28,7 @@ public class ServerMessageJob : IJob
         }
     }
 
-    private Task ExecuteTrigger()
+    private ValueTask ExecuteTrigger()
     {
         return serverMessageService.SaveCompletedMessageToDb();
     }

EVCB_OCPP.DBAPI/Middleware/ExceptionMiddleware.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json;
+
+namespace EVCB_OCPP.DBAPI.Middleware;
+
+public class ExceptionMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly ILogger<ExceptionMiddleware> logger;
+
+    public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger)
+    {
+        _next = next;
+        this.logger = logger;
+    }
+
+    public async Task Invoke(HttpContext context)
+    {
+        try
+        {
+            await _next(context);
+        }
+        catch (Exception ex)
+        {
+            var resultString = JsonConvert.SerializeObject(ex);
+            logger.LogError(resultString);
+            await context.Response.WriteAsync(resultString);
+        }
+    }
+}

EVCB_OCPP.DBAPI/Program.cs

@@ -4,12 +4,22 @@ using EVCB_OCPP.DBAPI.Services;
 using EVCB_OCPP.DBAPI.Services.DbService;
 using EVCB_OCPP.DBAPI.Services.ServerMessageServices;
 using EVCB_OCPP.Domain.Extensions;
+using Microsoft.Extensions.Hosting;
 using NLog.Extensions.Logging;
 using NLog.Web;
-using ServiceStack.Redis;
 using SQLitePCL;
+using StackExchange.Redis;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
 
-raw.SetProvider(new SQLite3Provider_e_sqlite3());
+//raw.SetProvider(new SQLite3Provider_e_sqlite3());
+
+//RedisConfig.CertificateValidationCallback = (
+//    object sender, 
+//    X509Certificate? certificate, 
+//    X509Chain? chain,
+//    SslPolicyErrors sslPolicyErrors) 
+//    => { return true; };
 
 var builder = Host.CreateDefaultBuilder(args)
     .ConfigureLogging((context, loggingBuilder) => {
@@ -26,14 +36,48 @@ var builder = Host.CreateDefaultBuilder(args)
         });
     })
     .ConfigureServices((context, services) => {
-        services.AddSingleton<IRedisClientsManager>(new RedisManagerPool(context.Configuration["RedisConnectionString"]));
+
+        var azureRedisHost = context.Configuration["AZURE_REDIS_HOST"];
+        var azureRedisPwd = context.Configuration["AZURE_REDIS_PASSWORD"];
+        var azureRedisPort = context.Configuration["AZURE_REDIS_PORT"];
+        var azureRedisIsSSL = context.Configuration["AZURE_REDIS_SSL"];
+        var azureRedisDb = context.Configuration["AZURE_REDIS_DATABASE"];
+        //var connString = $"redis://{azureRedisHost}:{azureRedisPort}?ssl={azureRedisIsSSL}&sslprotocols=Tls12&password={azureRedisPwd.UrlEncode()}&defaultDatabase={azureRedisDb}";
+        //var connString = $"{azureRedisHost}:{azureRedisPort}?ssl=true&password={azureRedisPwd}&db={azureRedisDb}";
+
+        //var connString = $"wSy0KUhPB7GAH1k28X6JzZ4102Ia679PFAzCaBbPc2I=@devtest-backend-redis.redis.cache.windows.net:6380";
+        //services.AddSingleton<IRedisClientsManager>(new PooledRedisClientManager(connString));
+
+        azureRedisHost = "devtest-backend-redis.redis.cache.windows.net";
+        azureRedisPwd = "SV213drVDPL7Vay7wBEXthU2expkuf2LlAzCaB64PQg=";
+        azureRedisPort = "6380";
+        azureRedisIsSSL = "true";
+        azureRedisDb = "0";
+
+        var connConfig = new ConfigurationOptions()
+        { 
+            EndPoints = { { azureRedisHost , int.Parse(azureRedisPort) } },
+            Password = azureRedisPwd,
+            Ssl = true,
+            DefaultDatabase = int.Parse(azureRedisDb)
+        };
+        connConfig.CertificateValidation += (object sender, X509Certificate? certificate, X509Chain? chain, SslPolicyErrors sslPolicyErrors) => { return true; };
+        services.AddSingleton<IDatabase>((service) => {
+            var conn =  ConnectionMultiplexer.Connect(connConfig);
+            return conn.GetDatabase();
+        });
+        services.AddSingleton<IServer>((service) => {
+            var conn = ConnectionMultiplexer.Connect(connConfig);
+            return conn.GetServer(connConfig.EndPoints.First());
+        });
 
         services.AddJobs();
 
         services.AddMainDbContext(context.Configuration);
         services.AddTransient<IMainDbService, MainDbService>();
 
-        services.AddTransient<IServerMessageService, SourceDbServerMessageService>();
+        services.AddTransient<IServerMessageService, MemDbServerMessageService>();
+        //services.AddTransient<IServerMessageService, RedisServerMessageService>();
         services.AddMemDbService();
     });
 

EVCB_OCPP.DBAPI/Services/ServerMessageServices/IServerMessageService.cs

@@ -4,10 +4,10 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices;
 
 public interface IServerMessageService
 {
-    Task<string> AddServerMessage(string ChargeBoxId, string OutAction, string OutRequest, string CreatedBy, DateTime? CreatedOn = null, string SerialNo = "", string InMessage = "", CancellationToken token = default);
-    Task<List<ServerMessage>> GetNeedSendToClientServerMessages();
-    Task<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default);
-    Task<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default);
-    Task<List<ServerMessage>> GetServerMessages();
-    Task SaveCompletedMessageToDb();
+    ValueTask<string> AddServerMessage(string ChargeBoxId, string OutAction, string OutRequest, string CreatedBy, DateTime? CreatedOn = null, string SerialNo = "", string InMessage = "", CancellationToken token = default);
+    ValueTask<List<ServerMessage>> GetNeedSendToClientServerMessages();
+    ValueTask<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default);
+    ValueTask<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default);
+    ValueTask<List<ServerMessage>> GetServerMessages();
+    ValueTask SaveCompletedMessageToDb();
 }

EVCB_OCPP.DBAPI/Services/ServerMessageServices/MemDbServerMessageService.cs

@@ -24,7 +24,7 @@ public class MemDbServerMessageService : IServerMessageService
     private readonly IMainDbService mainDbService;
     private readonly ILogger<MemDbServerMessageService> logger;
 
-    public async Task<string> AddServerMessage(
+    public async ValueTask<string> AddServerMessage(
         string ChargeBoxId,
         string OutAction,
         string OutRequest,
@@ -56,7 +56,7 @@ public class MemDbServerMessageService : IServerMessageService
         return SerialNo;
     }
 
-    public async Task<List<ServerMessage>> GetNeedSendToClientServerMessages()
+    public async ValueTask<List<ServerMessage>> GetNeedSendToClientServerMessages()
     {
         DateTime dt = new DateTime(1991, 1, 1);
         DateTime dateTimeNow = DateTime.UtcNow;
@@ -82,7 +82,7 @@ public class MemDbServerMessageService : IServerMessageService
         return datas.ToList();
     }
 
-    public async Task<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
+    public async ValueTask<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
     {
         DateTime _ReceivedOn = ReceivedOn == default ? DateTime.UtcNow : ReceivedOn;
 
@@ -107,7 +107,7 @@ public class MemDbServerMessageService : IServerMessageService
         return success;
     }
 
-    public async Task<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
+    public async ValueTask<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
     {
         DateTime _UpdatedOn = UpdatedOn == default ? DateTime.UtcNow : UpdatedOn;
 
@@ -131,7 +131,7 @@ public class MemDbServerMessageService : IServerMessageService
         return success;
     }
 
-    public async Task<List<ServerMessage>> GetServerMessages()
+    public async ValueTask<List<ServerMessage>> GetServerMessages()
     {
         string cmd = """
             SELECT * FROM ServerMessage
@@ -141,7 +141,7 @@ public class MemDbServerMessageService : IServerMessageService
         return datas.ToList();
     }
 
-    public static async Task IinitMemDbAsync(SqliteConnection connection)
+    public static async ValueTask IinitMemDbAsync(SqliteConnection connection)
     {
         var createTableResult = await connection.ExecuteAsync("""
             CREATE TABLE IF NOT EXISTS ServerMessage (
@@ -159,7 +159,7 @@ public class MemDbServerMessageService : IServerMessageService
             """);
     }
 
-    public async Task SaveCompletedMessageToDb()
+    public async ValueTask SaveCompletedMessageToDb()
     {
         List<ServerMessage> completedMessages = await GetCompletedServerMessageFromMemDb();
         List<Task<int>> addServerMessageTasks = new List<Task<int>>();

EVCB_OCPP.DBAPI/Services/ServerMessageServices/RedisServerMessageService.cs

@@ -1,33 +1,35 @@
 using EVCB_OCPP.DBAPI.Services.DbService;
 using EVCB_OCPP.Domain.Models.MainDb;
-using ServiceStack;
-using ServiceStack.Redis;
+using Newtonsoft.Json;
+using NRedisStack.RedisStackCommands;
+using Quartz.Impl.AdoJobStore.Common;
+using StackExchange.Redis;
+using System.Collections.Generic;
+using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices;
 
 public class RedisServerMessageService : IServerMessageService
 {
+    private const string ServerMessageCntKey = "ServerMessageCntKey";
+    private const string ServerMessageObjectPrefix = "ServerMessageObjectPrefix_";
+    private string ServerMessageObjectPattern => "ServerMessageObjectPrefix_*";
+
     private readonly IMainDbService mainDbService;
-    private readonly IRedisClientsManager redisClientsManager;
+    private readonly IDatabase redisDatabase;
+    private readonly IServer redisServer;
 
     public RedisServerMessageService(
         IMainDbService mainDbService,
-        IRedisClientsManager redisClientsManager
-        )
+        IDatabase redisDatabase,
+        IServer redisServer)
     {
         this.mainDbService = mainDbService;
-        this.redisClientsManager = redisClientsManager;
+        this.redisDatabase = redisDatabase;
+        this.redisServer = redisServer;
     }
 
-    public async Task<string> AddServerMessage(
-        string ChargeBoxId,
-        string OutAction,
-        string OutRequest,
-        string CreatedBy,
-        DateTime? CreatedOn = null,
-        string SerialNo = "",
-        string InMessage = "",
-        CancellationToken token = default)
+    public async ValueTask<string> AddServerMessage(string ChargeBoxId, string OutAction, string OutRequest, string CreatedBy, DateTime? CreatedOn = null, string SerialNo = "", string InMessage = "", CancellationToken token = default)
     {
         if (string.IsNullOrEmpty(SerialNo))
         {
@@ -53,37 +55,77 @@ public class RedisServerMessageService : IServerMessageService
         return SerialNo;
     }
 
-    public async Task<List<ServerMessage>> GetNeedSendToClientServerMessages()
+    public async ValueTask<List<ServerMessage>> GetNeedSendToClientServerMessages()
     {
         var allServerMessage = await GetServerMessages();
         DateTime startDt = DateTime.UtcNow.AddSeconds(-30);
 
         var seperatedServerMessage = allServerMessage.GroupBy(x => x.CreatedOn < startDt).ToDictionary(x => x.Key, x => x?.ToList());
-        var deprecatedServerMessage = seperatedServerMessage.GetValueOrDefault(true, null);
+        var deprecatedServerMessages = seperatedServerMessage.GetValueOrDefault(true, null);
 
-        if (deprecatedServerMessage is not null)
+        if (deprecatedServerMessages is not null)
         {
-            var deprecatedServerMessageIds = deprecatedServerMessage.Select(x => x.Id);
-            await RemoveFromRedis(deprecatedServerMessageIds);
+            var deprecatedServerMessageIds = deprecatedServerMessages.Select(x => x.Id);
+            await RemoveFromRedis(deprecatedServerMessages);
 
-            foreach (var servermessage in deprecatedServerMessage)
+            foreach (var servermessage in deprecatedServerMessages)
             {
                 _ = AddServerMessageToDbAsync(servermessage);
             }
         }
 
-        return seperatedServerMessage.GetValueOrDefault(false, new List<ServerMessage>())!;
+        var toReturn = seperatedServerMessage.GetValueOrDefault(false, new List<ServerMessage>())!;
+
+        if (allServerMessage.Count > 0)
+        {
+
+        }
+
+        if (toReturn.Count > 0)
+        {
+
+        }
+        return toReturn;
     }
 
-    public async Task<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
+    public async ValueTask<List<ServerMessage>> GetServerMessages()
+    {
+        //var msgs = await redisDatabase.SortedSetRangeByScoreAsync(ServerMessageSetsKey);
+        var keys = redisServer.Keys(pattern: ServerMessageObjectPattern);
+        var msgs = redisDatabase.StringGet(keys.ToArray());
+        List<ServerMessage> toReturn = new List<ServerMessage>();
+        foreach (var msg in msgs)
+        {
+            try
+            {
+                var result = JsonConvert.DeserializeObject<ServerMessage>(msg);
+                toReturn.Add(result);
+            }
+            catch(Exception e)
+            {
+
+            }
+        }
+        return toReturn;
+    }
+
+    public ValueTask SaveCompletedMessageToDb()
+    {
+        return ValueTask.CompletedTask;
+    }
+
+    public async ValueTask<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
     {
         DateTime _ReceivedOn = ReceivedOn == default ? DateTime.UtcNow : ReceivedOn;
 
-        IRedisClientAsync redisClient = await redisClientsManager.GetClientAsync();
-        var redisServerMessage = redisClient.As<ServerMessage>();
-        var msg = await redisServerMessage.GetByIdAsync(id);
-        await redisServerMessage.DeleteByIdAsync(id);
-        await redisClient.DisposeAsync();
+        var key = GetKeyById(id);
+        var redisValue = redisDatabase.StringGet(key);
+        redisDatabase.KeyDelete(key);
+        //var redisServerMessages = provider.RedisCollection<ServerMessage>();
+        //var msgs = await redisDatabase.SortedSetRangeByScoreAsync(ServerMessageSetsKey, id, id);
+        //var removedCnt = await redisDatabase.SortedSetRemoveAsync(ServerMessageSetsKey, msgs);
+
+        var msg = JsonConvert.DeserializeObject<ServerMessage>(redisValue);
 
         msg.Id = 0;
         msg.InMessage = InMessage;
@@ -93,35 +135,60 @@ public class RedisServerMessageService : IServerMessageService
         return !string.IsNullOrEmpty(addServerMessageResult);
     }
 
-    public async Task<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
+    public async ValueTask<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
     {
         DateTime _UpdatedOn = UpdatedOn == default ? DateTime.UtcNow : UpdatedOn;
 
-        IRedisClientAsync redisClient = await redisClientsManager.GetClientAsync();
-        var redisServerMessage = redisClient.As<ServerMessage>();
-        var msg = await redisServerMessage.GetByIdAsync(id);
+        var key = GetKeyById(id);
+        //var msgs = await redisDatabase.SortedSetRangeByScoreAsync(ServerMessageSetsKey, id, id);
+        //var removedCnt = await redisDatabase.SortedSetRemoveAsync(ServerMessageSetsKey, msgs);
+        //var redisMsg = msgs.FirstOrDefault();
+        var redisMsg = redisDatabase.StringGet(key);
+        var msg = JsonConvert.DeserializeObject<ServerMessage>(redisMsg);
 
         msg.UpdatedOn = _UpdatedOn;
 
-        await redisServerMessage.StoreAsync(msg);
-        await redisClient.DisposeAsync();
+        redisDatabase.StringSet(key, JsonConvert.SerializeObject(msg));
+
+        //await redisDatabase.SortedSetAddAsync(ServerMessageSetsKey, JsonConvert.SerializeObject(msg), id);
+
         return true;
     }
 
-    public async Task<List<ServerMessage>> GetServerMessages()
+    private async ValueTask StoreIntoRedis(ServerMessage data)
+    {
+        data.Id = await GetNextIndex();
+        var key = GetKeyById(data.Id);
+
+        redisDatabase.StringSet(key, JsonConvert.SerializeObject(data));
+
+        //var result = await redisDatabase.SortedSetAddAsync(ServerMessageSetsKey, JsonConvert.SerializeObject(data), data.Id);
+        return;
+    }
+
+    private async Task<int> GetNextIndex()
     {
-        IRedisClientAsync redisClient = await redisClientsManager.GetClientAsync();
-        var allMessages = await redisClient.As<ServerMessage>().GetAllAsync();
-        await redisClient.DisposeAsync();
-        return allMessages?.ToList();
+        var index = await redisDatabase.StringIncrementAsync(ServerMessageCntKey);
+        return (int)index;
     }
 
-    public Task SaveCompletedMessageToDb()
+    private async Task RemoveFromRedis(IEnumerable<ServerMessage> datas)
     {
-        return Task.CompletedTask;
+        //RedisValue[] ids = Array.ConvertAll(datas.Select(x => x.Id).ToArray() , x => (RedisValue)x);
+        var ids = datas.Select(x => GetKeyById(x.Id));
+
+
+        foreach (var id in ids)
+        {
+            //var deletedCnts = await redisDatabase.SortedSetRemoveRangeByScoreAsync(ServerMessageSetsKey, id, id);
+
+            //redisDatabase.StringGetDelete(id);
+            redisDatabase.KeyDelete(id);
+        }
+        return;
     }
 
-    private async Task<int> AddServerMessageToDbAsync(ServerMessage message)
+    private async ValueTask<int> AddServerMessageToDbAsync(ServerMessage message)
     {
         var memMessageId = message.Id;
         var addServerMessageResult = await mainDbService.AddServerMessage(message);
@@ -132,25 +199,8 @@ public class RedisServerMessageService : IServerMessageService
         return -1;
     }
 
-    private async Task StoreIntoRedis(ServerMessage data)
-    {
-        await using IRedisClientAsync redisClient = await redisClientsManager.GetClientAsync();
-        var redisServerMessage = redisClient.As<ServerMessage>();
-        data.Id = (int)await redisServerMessage.GetNextSequenceAsync();
-        await redisServerMessage.StoreAsync(data);
-    }
-
-    private async Task RemoveFromRedis(int id)
-    {
-        await using IRedisClientAsync redisClient = await redisClientsManager.GetClientAsync();
-        var redisServerMessage = redisClient.As<ServerMessage>();
-        await redisServerMessage.DeleteByIdAsync(id);
-    }
-
-    private async Task RemoveFromRedis(IEnumerable<int> ids)
+    private string GetKeyById(int id)
     {
-        await using IRedisClientAsync redisClient = await redisClientsManager.GetClientAsync();
-        var redisServerMessage = redisClient.As<ServerMessage>();
-        await redisServerMessage.DeleteByIdsAsync(ids);
+        return ServerMessageObjectPattern.Replace("*", id.ToString());
     }
 }

EVCB_OCPP.DBAPI/Services/ServerMessageServices/ServiceStackRedisServerMessageService.cs

@@ -0,0 +1,154 @@
+using EVCB_OCPP.DBAPI.Services.DbService;
+using EVCB_OCPP.Domain.Models.MainDb;
+
+namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices;
+
+//public class ServiceStackRedisServerMessageService : IServerMessageService
+//{
+//    private readonly IMainDbService mainDbService;
+//    private readonly IRedisClientsManager redisClientsManager;
+
+//    public ServiceStackRedisServerMessageService(
+//        IMainDbService mainDbService,
+//        IRedisClientsManager redisClientsManager
+//        )
+//    {
+//        this.mainDbService = mainDbService;
+//        this.redisClientsManager = redisClientsManager;
+//    }
+
+//    public async ValueTask<string> AddServerMessage(
+//        string ChargeBoxId,
+//        string OutAction,
+//        string OutRequest,
+//        string CreatedBy,
+//        DateTime? CreatedOn = null,
+//        string SerialNo = "",
+//        string InMessage = "",
+//        CancellationToken token = default)
+//    {
+//        if (string.IsNullOrEmpty(SerialNo))
+//        {
+//            SerialNo = Guid.NewGuid().ToString();
+//        }
+//        var _CreatedOn = CreatedOn ?? DateTime.UtcNow;
+
+//        string _OutRequest = OutRequest is not null ? OutRequest : "";
+
+//        var data = new ServerMessage()
+//        {
+//            ChargeBoxId = ChargeBoxId,
+//            CreatedBy = CreatedBy,
+//            CreatedOn = _CreatedOn,
+//            OutAction = OutAction,
+//            OutRequest = _OutRequest,
+//            SerialNo = SerialNo,
+//            InMessage = InMessage
+//        };
+
+//        await StoreIntoRedis(data);
+
+//        return SerialNo;
+//    }
+
+//    public async ValueTask<List<ServerMessage>> GetNeedSendToClientServerMessages()
+//    {
+//        var allServerMessage = await GetServerMessages();
+//        DateTime startDt = DateTime.UtcNow.AddSeconds(-30);
+
+//        var seperatedServerMessage = allServerMessage.GroupBy(x => x.CreatedOn < startDt).ToDictionary(x => x.Key, x => x?.ToList());
+//        var deprecatedServerMessage = seperatedServerMessage.GetValueOrDefault(true, null);
+
+//        if (deprecatedServerMessage is not null)
+//        {
+//            var deprecatedServerMessageIds = deprecatedServerMessage.Select(x => x.Id);
+//            await RemoveFromRedis(deprecatedServerMessageIds);
+
+//            foreach (var servermessage in deprecatedServerMessage)
+//            {
+//                _ = AddServerMessageToDbAsync(servermessage);
+//            }
+//        }
+
+//        return seperatedServerMessage.GetValueOrDefault(false, new List<ServerMessage>())!;
+//    }
+
+//    public async ValueTask<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
+//    {
+//        DateTime _ReceivedOn = ReceivedOn == default ? DateTime.UtcNow : ReceivedOn;
+
+//        IRedisClient redisClient = redisClientsManager.GetClient();
+//        var redisServerMessage = redisClient.As<ServerMessage>();
+//        var msg = redisServerMessage.GetById(id);
+//        redisServerMessage.DeleteById(id);
+//        redisClient.Dispose();
+
+//        msg.Id = 0;
+//        msg.InMessage = InMessage;
+//        msg.ReceivedOn = _ReceivedOn;
+
+//        var addServerMessageResult = await mainDbService.AddServerMessage(msg);
+//        return !string.IsNullOrEmpty(addServerMessageResult);
+//    }
+
+//    public async ValueTask<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
+//    {
+//        DateTime _UpdatedOn = UpdatedOn == default ? DateTime.UtcNow : UpdatedOn;
+
+//        IRedisClient redisClient = redisClientsManager.GetClient();
+//        var redisServerMessage = redisClient.As<ServerMessage>();
+//        var msg = redisServerMessage.GetById(id);
+
+//        msg.UpdatedOn = _UpdatedOn;
+
+//        redisServerMessage.Store(msg);
+//        redisClient.Dispose();
+//        return true;
+//    }
+
+//    public async ValueTask<List<ServerMessage>> GetServerMessages()
+//    {
+//        IRedisClient redisClient = redisClientsManager.GetClient();
+//        var allMessages = redisClient.As<ServerMessage>().GetAll();
+//        redisClient.Dispose();
+//        return allMessages?.ToList();
+//    }
+
+//    public ValueTask SaveCompletedMessageToDb()
+//    {
+//        return ValueTask.CompletedTask;
+//    }
+
+//    private async ValueTask<int> AddServerMessageToDbAsync(ServerMessage message)
+//    {
+//        var memMessageId = message.Id;
+//        var addServerMessageResult = await mainDbService.AddServerMessage(message);
+//        if (!string.IsNullOrEmpty(addServerMessageResult))
+//        {
+//            return memMessageId;
+//        }
+//        return -1;
+//    }
+
+//    private async Task StoreIntoRedis(ServerMessage data)
+//    {
+//        using IRedisClient redisClient = redisClientsManager.GetClient();        
+//        var redisServerMessage = redisClient.As<ServerMessage>();
+//        data.Id = (int)redisServerMessage.GetNextSequence();
+//        redisServerMessage.Store(data);
+//    }
+
+//    private async Task RemoveFromRedis(int id)
+//    {
+//        using IRedisClient redisClient = redisClientsManager.GetClient();
+//        var redisServerMessage = redisClient.As<ServerMessage>();
+//        redisServerMessage.DeleteById(id);
+//    }
+
+//    private async Task RemoveFromRedis(IEnumerable<int> ids)
+//    {
+//        using IRedisClient redisClient = redisClientsManager.GetClient();
+//        var redisServerMessage = redisClient.As<ServerMessage>();
+//        redisServerMessage.DeleteByIds(ids);
+//    }
+//}

EVCB_OCPP.DBAPI/Services/ServerMessageServices/SourceDbServerMessageService.cs

@@ -20,7 +20,7 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices
             this.sqlConnectionFactory = sqlConnectionFactory;
         }
 
-        public async Task<string> AddServerMessage(
+        public async ValueTask<string> AddServerMessage(
             string ChargeBoxId,
             string OutAction,
             string OutRequest,
@@ -54,7 +54,7 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices
             return SerialNo;
         }
 
-        public async Task<List<ServerMessage>> GetNeedSendToClientServerMessages()
+        public async ValueTask<List<ServerMessage>> GetNeedSendToClientServerMessages()
         {
             var allServerMessage = await GetServerMessages();
             DateTime startDt = DateTime.UtcNow.AddSeconds(-30);
@@ -75,17 +75,17 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices
             return seperatedServerMessage.GetValueOrDefault(false, new List<ServerMessage>())!;
         }
 
-        public Task<List<ServerMessage>> GetServerMessages()
+        public ValueTask<List<ServerMessage>> GetServerMessages()
         {
             return GetServerMessagesFromRTTable();
         }
 
-        public Task SaveCompletedMessageToDb()
+        public ValueTask SaveCompletedMessageToDb()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public async Task<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
+        public async ValueTask<bool> SetServerMessageResponseReceived(int id, string InMessage = "", DateTime ReceivedOn = default)
         {
             DateTime _ReceivedOn = ReceivedOn == default ? DateTime.UtcNow : ReceivedOn;
 
@@ -104,7 +104,7 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices
             return string.IsNullOrEmpty(sn);
         }
 
-        public Task<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
+        public ValueTask<bool> SetServerMessageServerHandling(int id, DateTime UpdatedOn = default)
         {
             DateTime _UpdatedOn = UpdatedOn == default ? DateTime.UtcNow : UpdatedOn;
             return SetServerMessageServerHandlingInRTTable(id, _UpdatedOn);
@@ -144,7 +144,7 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices
             return cnts > 0;
         }
 
-        private async Task<List<ServerMessage>> GetServerMessagesFromRTTable()
+        private async ValueTask<List<ServerMessage>> GetServerMessagesFromRTTable()
         {
             var cmd = """
                 SELECT * FROM RTServerMessage
@@ -185,7 +185,7 @@ namespace EVCB_OCPP.DBAPI.Services.ServerMessageServices
             return cnts > 0;
         }
 
-        private async Task<bool> SetServerMessageServerHandlingInRTTable(int id, DateTime updatedOn)
+        private async ValueTask<bool> SetServerMessageServerHandlingInRTTable(int id, DateTime updatedOn)
         {
             var cmd = """
                 UPDATE RTServerMessage

EVCB_OCPP.DBAPI/Startup.cs

@@ -1,5 +1,7 @@
 using Newtonsoft.Json;
 using Microsoft.Extensions.DependencyInjection;
+using EVCB_OCPP.DBAPI.Middleware;
+using System.Reflection.PortableExecutable;
 
 namespace EVCB_OCPP.DBAPI;
 
@@ -47,6 +49,7 @@ public class Startup
         }
 
         app.UseRouting();
+        app.UseMiddleware<ExceptionMiddleware>();
         //app.UseAuthorization();
         app.UseEndpoints(endpoints =>
         {