temp

EVCB_OCPP.WSServer/Helper/GroupHandlerIO.cs

@@ -92,6 +92,8 @@ public class GroupHandler<TI,TO> where TI : class
             var completedRequests = requests.Where(x => completedKeys.Any(y=> y == x.Data)).ToList();
             foreach (var request in completedRequests)
             {
+                var result = bundleHandledata.CompletedDatas.FirstOrDefault(x => x.Key == request.Data);
+                request.Result = result.Value;
                 request.Waiter.Release();
             }
 
@@ -144,7 +146,7 @@ public class BundleHandlerData<TI,TO>
 internal class WaitParam<TI,TO>
 {
     public TI Data { get; init; }
-    public TO Result { get; init; }
+    public TO Result { get; set; }
     public SemaphoreSlim Waiter { get; init; }
     public Exception Exception { get; set; }
 }

EVCB_OCPP.WSServer/ProtalServer.cs

@@ -165,7 +165,7 @@ namespace EVCB_OCPP.WSServer
         };
         private CancellationTokenSource _cts = new CancellationTokenSource();
         private CancellationToken _ct;
-        private Semaphore bootSemaphore = new Semaphore(10, 10);
+        //private Semaphore bootSemaphore = new Semaphore(10, 10);
         #endregion
 
         internal Dictionary<string, WsClientData> GetClientDic()
@@ -722,8 +722,9 @@ namespace EVCB_OCPP.WSServer
                                 {
                                     session.ChargePointVendor = bootNotificationRequest.chargePointVendor;
 
-                                    if (session.BootStatus == BootStatus.Startup &&
-                                        bootSemaphore.WaitOne(0))
+                                    if (session.BootStatus == BootStatus.Startup
+                                        //&& bootSemaphore.WaitOne(0)
+                                        )
                                     {
                                         session.BootStatus = BootStatus.Initializing;
                                         session.AddTask(StartInitializeEVSE(session));
@@ -1018,7 +1019,7 @@ namespace EVCB_OCPP.WSServer
         {
             await InitializeEVSE(session);
             session.BootStatus = BootStatus.Pending;
-            bootSemaphore.Release();
+            //bootSemaphore.Release();
         }
 
         private async Task InitializeEVSE(WsClientData session)

EVCB_OCPP.WSServer/Service/ConfirmWaitingMessageSerevice.cs

@@ -198,30 +198,34 @@ namespace EVCB_OCPP.WSServer.Service
             }
         }
 
-        internal async Task<MessageResult> SendAndWaitUntilResultAsync(Func<Task<string>> startSendTaskFunc, CancellationToken token = default)
+        internal async Task<object> SendAndWaitUntilResultAsync(Func<Task<string>> startSendTaskFunc, CancellationToken token = default)
         {
-            MessageResult response;
+            object message;
             do
             {
                 var requestId = await startSendTaskFunc();
-                response = await WaitResultAsync(requestId, token: token);
+                message = await WaitResultAsync(requestId, token: token);
             }
-            while (response == null && !token.IsCancellationRequested);
-            return response;
+            while (message == null && !token.IsCancellationRequested);
+            return message;
         }
 
-        internal async Task<MessageResult> WaitResultAsync(string msgId, int maxWaitSec = 65000, CancellationToken token = default)
+        internal async Task<object> WaitResultAsync(string msgId, int maxWaitSec = 65000, CancellationToken token = default)
         {
-            if (!asyncWaitingTasks.Keys.Contains(msgId))
+            if (!needConfirmPacketList.Select(x=>x.RequestId).Contains(msgId))
             {
-                return await mainDbService.TryGetResponseFromDb(msgId);
+                var checkResult =  await mainDbService.TryGetResponseFromDb(msgId, token);
+                if (checkResult is not null)
+                {
+                    return checkResult;
+                }
             }
 
             var waiObj = new MessageResultWaitObject();
             asyncWaitingTasks.Add(msgId, waiObj);
             var task = waiObj.Lock.WaitAsync(token);
             var completedTask = await Task.WhenAny(task, Task.Delay(180_000));
-            return waiObj.Result;
+            return waiObj.Result.Message;
         }
 
         private void RemoveWaitingMsg(

EVCB_OCPP.WSServer/Service/DbService/MainDbService.cs

@@ -2,6 +2,14 @@
 using EVCB_OCPP.Domain;
 using EVCB_OCPP.Domain.ConnectionFactory;
 using EVCB_OCPP.Domain.Models.MainDb;
+using EVCB_OCPP.Packet.Features;
+using EVCB_OCPP.Packet.Messages.Core;
+using EVCB_OCPP.Packet.Messages.FirmwareManagement;
+using EVCB_OCPP.Packet.Messages.LocalAuthListManagement;
+using EVCB_OCPP.Packet.Messages.RemoteTrigger;
+using EVCB_OCPP.Packet.Messages.Reservation;
+using EVCB_OCPP.Packet.Messages.Security;
+using EVCB_OCPP.Packet.Messages.SmartCharging;
 using EVCB_OCPP.WSServer.Helper;
 using EVCB_OCPP.WSServer.Message;
 using Microsoft.AspNetCore.Connections;
@@ -50,7 +58,7 @@ public interface IMainDbService
     Task AddMachineConfiguration(string chargeBoxId, string key, string value, bool isReadOnly, bool isExist = true);
     Task UpdateMachineConfiguration(string chargeBoxId, string item, string empty, bool v, bool isExists = true);
     Task<List<MachineConfigurations>> GetMachineConfiguration(string chargeBoxId);
-    Task<MessageResult> TryGetResponseFromDb(string msgId);
+    Task<object> TryGetResponseFromDb(string msgId, CancellationToken token = default);
 }
 
 public class MainDbService : IMainDbService
@@ -444,6 +452,75 @@ public class MainDbService : IMainDbService
         }
     }
 
+    public async Task<object> TryGetResponseFromDb(string msgId, CancellationToken token = default)
+    {
+        var parameters = new DynamicParameters();
+        parameters.Add("@MID", msgId, DbType.String, size: 36);
+        parameters.Add("@MT", DateTime.UtcNow.AddSeconds(-5), DbType.DateTime);
+
+        var sql = """
+            SELECT [OutAction],[InMessage]
+            FROM [ServerMessage]
+            WHERE [SerialNo] = @MID AND CreatedOn > @MT
+            """;
+        using var conn = await sqlConnectionFactory.CreateAsync();
+        ServerMessage item = null;
+        item = await conn.QueryFirstOrDefaultAsync<ServerMessage>(new CommandDefinition(sql, parameters: parameters, cancellationToken: token));
+
+        Actions action = Actions.None;
+        if (item is null ||
+            !Enum.TryParse(item.OutAction, out action))
+        {
+            return null;
+        }
+
+        switch (action)
+        {
+            case Actions.GetConfiguration:
+                return JsonConvert.DeserializeObject<GetConfigurationConfirmation>(item.InMessage);
+            case Actions.ChangeConfiguration:
+                return JsonConvert.DeserializeObject<ChangeConfigurationConfirmation>(item.InMessage);
+            case Actions.RemoteStartTransaction:
+                return JsonConvert.DeserializeObject<RemoteStartTransactionConfirmation>(item.InMessage);
+            case Actions.RemoteStopTransaction:
+                return JsonConvert.DeserializeObject<RemoteStopTransactionConfirmation>(item.InMessage);
+            case Actions.ChangeAvailability:
+                return JsonConvert.DeserializeObject<ChangeAvailabilityConfirmation>(item.InMessage);
+            case Actions.ClearCache:
+                return JsonConvert.DeserializeObject<ClearCacheConfirmation>(item.InMessage);
+            case Actions.DataTransfer:
+                return JsonConvert.DeserializeObject<DataTransferConfirmation>(item.InMessage);
+            case Actions.Reset:
+                return JsonConvert.DeserializeObject<ResetConfirmation>(item.InMessage);
+            case Actions.UnlockConnector:
+                return JsonConvert.DeserializeObject<UnlockConnectorConfirmation>(item.InMessage);
+            case Actions.TriggerMessage:
+                return JsonConvert.DeserializeObject<TriggerMessageConfirmation>(item.InMessage);
+            case Actions.GetDiagnostics:
+                return JsonConvert.DeserializeObject<GetDiagnosticsConfirmation>(item.InMessage);
+            case Actions.UpdateFirmware:
+                return JsonConvert.DeserializeObject<UpdateFirmwareConfirmation>(item.InMessage);
+            case Actions.GetLocalListVersion:
+                return JsonConvert.DeserializeObject<GetLocalListVersionConfirmation>(item.InMessage);
+            case Actions.SendLocalList:
+                return JsonConvert.DeserializeObject<SendLocalListConfirmation>(item.InMessage);
+            case Actions.SetChargingProfile:
+                return JsonConvert.DeserializeObject<SetChargingProfileConfirmation>(item.InMessage);
+            case Actions.ClearChargingProfile:
+                return JsonConvert.DeserializeObject<ClearChargingProfileConfirmation>(item.InMessage);
+            case Actions.GetCompositeSchedule:
+                return JsonConvert.DeserializeObject<GetCompositeScheduleConfirmation>(item.InMessage);
+            case Actions.ReserveNow:
+                return JsonConvert.DeserializeObject<ReserveNowConfirmation>(item.InMessage);
+            case Actions.CancelReservation:
+                return JsonConvert.DeserializeObject<CancelReservationConfirmation>(item.InMessage);
+            case Actions.ExtendedTriggerMessage:
+                return JsonConvert.DeserializeObject<ExtendedTriggerMessageConfirmation>(item.InMessage);
+            default:
+                return null;
+        }
+    }
+
     private void InitUpdateConnectorStatusHandler()
     {
         if (statusNotificationHandler is not null)
@@ -593,7 +670,12 @@ public class MainDbService : IMainDbService
         var gReult = result.GroupBy(x => x.ChargeBoxId);
         foreach (var g in gReult)
         {
-            bundleHandlerData.AddCompletedData(g.Key, g.ToList());
+            var originKey = chargeboxIds.FirstOrDefault(x=> x.ToLower() == g.Key.ToLower());
+            if (string.IsNullOrEmpty(originKey))
+            {
+                continue;
+            }
+            bundleHandlerData.AddCompletedData(originKey, g.ToList());
         }
     }
 

EVCB_OCPP.WSServer/Service/StationConfigService.cs

@@ -138,8 +138,8 @@ public class StationConfigService
 
     private async Task UpdateEvseConfig(string chargeBoxId, int stationId, CancellationToken token = default)
     {
-        MessageResult getEvseCurrentConfigResponse = await GetEvseCurrentConfig(chargeBoxId, token);
-        if (!getEvseCurrentConfigResponse.Success || getEvseCurrentConfigResponse.Message is not GetConfigurationConfirmation confirmation)
+        GetConfigurationConfirmation confirmation = await GetEvseCurrentConfig(chargeBoxId, token);
+        if (confirmation is null)
         {
             logger.LogWarning("{chargeBoxId} get config from evse failed", chargeBoxId);
             return;
@@ -162,11 +162,15 @@ public class StationConfigService
     }
 
 
-    private async Task<MessageResult> GetEvseCurrentConfig(string chargeBoxId, CancellationToken token = default)
+    private async Task<GetConfigurationConfirmation> GetEvseCurrentConfig(string chargeBoxId, CancellationToken token = default)
     {
         var sendTask = async () => await messageService.SendGetEVSEConfigureRequest(chargeBoxId);
         var response = await confirmWaitingMessageSerevice.SendAndWaitUntilResultAsync(sendTask, token);
-        return response;
+        if (response is GetConfigurationConfirmation confirmation)
+        {
+            return confirmation;
+        }
+        return null;
     }
 
     private async Task<Dictionary<string, string>> GetEvseDBCurrentConfig(string chargeBoxId, CancellationToken token = default)
@@ -201,7 +205,7 @@ public class StationConfigService
                 continue;
             }
 
-            MessageResult response = null;
+            object response = null;
             var sendTask = async () => await messageService.SendChangeConfigurationRequest(chargeBoxId, config.Key, config.Value);
             response = await confirmWaitingMessageSerevice.SendAndWaitUntilResultAsync(sendTask, token);
         }

EVCB_OCPP.WSServer/Service/VendorIdUpdateService.cs

@@ -49,10 +49,9 @@ namespace EVCB_OCPP.WSServer.Service
 
         internal async Task GetAndRecordVendorId(WsClientData wsClient, CancellationToken token)
         {
-            var getEvseCurrentConfigResponse = await GetEvseCurrentConfig(wsClient.ChargeBoxId, token);
+            var confirmation = await GetEvseCurrentConfig(wsClient.ChargeBoxId, token);
 
-            if (!getEvseCurrentConfigResponse.Success ||
-                getEvseCurrentConfigResponse.Message is not GetConfigurationConfirmation confirmation)
+            if (confirmation is null)
             {
                 logger.LogWarning("{chargeBoxId} get config from evse failed", wsClient.ChargeBoxId);
                 return;
@@ -85,11 +84,15 @@ namespace EVCB_OCPP.WSServer.Service
         }
 
 
-        private async Task<MessageResult> GetEvseCurrentConfig(string chargeBoxId, CancellationToken token = default)
+        private async Task<GetConfigurationConfirmation> GetEvseCurrentConfig(string chargeBoxId, CancellationToken token = default)
         {
             var sendTask = async () => await messageService.SendGetEVSEConfigureRequest(chargeBoxId);
             var response = await confirmWaitingMessageSerevice.SendAndWaitUntilResultAsync(sendTask, token);
-            return response;
+            if (response is GetConfigurationConfirmation confirm)
+            {
+                return confirm;
+            }
+            return null;
         }
 
         private string GetChargeBoxIdVendorId(string chargeBoxId)