dbapi/EVCB_OCPP.DBAPI/Services/ServerMessageServices/ServiceStackRedisServerMessageService.cs

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);
//    }
//}