代码修改

ningshuxia

2024-03-20 785c92f5078cb7aeb05b13f6da627defb6525b36

 IStation.Application.Core/1-dispatch/1-solution/DispatchSolution_Controller.cs

@@ -29,103 +29,17 @@
            Log.Debug(flowId, JsonHelper.Object2Json(input));

            var scadaInput = GetScadaDispatchInput(DateTime.Now.AddSeconds(300), DateTime.Now);
            var scadaOutput = await GetRealScada1(flowId, scadaInput);
            var scadaOutput = await GetRealScada(flowId, scadaInput);
            if (scadaOutput == null || scadaOutput.Scadas == null)
            {
                Log.Info(flowId, "Scada:数据获取失败，调度终止!");
                throw YOops.Oh(eResultCode.Error, ErrorCodes.L001, "Scada:数据获取失败，调度终止!");
            }


            return new DispatchSolutionOutput();
            return TempOutHelper.GetDispatchSolutionOutput(input.FlowId);
        }

        private async Task<ScadaDispatchOutput> GetRealScada(string flowId, ScadaDispatchInput input)
        {
            if (input == null)
            {
                Log.Info(flowId, "ScadaDispatchInput is null");
                return default;
            }

            var ws = await CreateAsync("ws://localhost:5102/api/WebSocket/GetNotReadCount");
            if (ws == null || ws.State != WebSocketState.Open)
            {
                Log.Info(flowId, "webSocket:连接失败!");
                return default;
            }
            Log.Info(flowId, "webSocket:连接成功!");

            ScadaDispatchOutput output = null;
            var inputJson = JsonHelper.Object2FormatJson(input);
            Log.Debug(flowId, inputJson);
            var inputBytes = Encoding.UTF8.GetBytes(inputJson);
            await ws.SendAsync(inputBytes, WebSocketMessageType.Text, true, CancellationToken.None);
            try
            {
                var buffer = new ArraySegment<byte>(new byte[1024 * 4]);
                WebSocketReceiveResult result = null;
                using (var ms = new MemoryStream())
                {
                    do
                    {
                        result = await ws.ReceiveAsync(buffer, CancellationToken.None);
                        ms.Write(buffer.Array, buffer.Offset, result.Count);
                    }
                    while (!result.EndOfMessage);

                    ms.Seek(0, SeekOrigin.Begin);
                    if (result.MessageType == WebSocketMessageType.Text && !result.CloseStatus.HasValue)
                    {
                        using (var reader = new StreamReader(ms, Encoding.UTF8))
                        {
                            string outputJson = reader.ReadToEnd();
                            output = new ScadaDispatchOutput();
                            output.Scadas = JsonHelper.Json2Object<Dictionary<string, Dictionary<DateTime, string>>>(outputJson);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(flowId, ex.Message);
            }
            finally
            {
                try
                {
                    //关闭WebSocket
                    await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "AcknowledgeCloseframe", CancellationToken.None);
                }
                catch (Exception ex)
                {
                    Log.Error(flowId, "关闭WebSocket异常", ex);
                }
                ws.Abort();
                ws.Dispose();
            }

            return output;
        }

        /// <summary>
        /// 创建客户端实例
        /// </summary> 
        /// <returns></returns>
        public static async Task<ClientWebSocket> CreateAsync(string ServerUri)
        {
            var webSocket = new ClientWebSocket();
            webSocket.Options.RemoteCertificateValidationCallback = delegate { return true; };

            await webSocket.ConnectAsync(new Uri(ServerUri), CancellationToken.None);
            if (webSocket.State == WebSocketState.Open)
            {
                return webSocket;
            }
            return null;
        }

        private async Task<ScadaDispatchOutput> GetRealScada1(string flowId, ScadaDispatchInput input)
        {
            if (input == null)
            {
@@ -381,5 +295,91 @@



        //private async Task<ScadaDispatchOutput> GetRealScada(string flowId, ScadaDispatchInput input)
        //{
        //    if (input == null)
        //    {
        //        Log.Info(flowId, "ScadaDispatchInput is null");
        //        return default;
        //    }

        //    var ws = await CreateAsync("ws://localhost:5102/api/WebSocket/GetNotReadCount");
        //    if (ws == null || ws.State != WebSocketState.Open)
        //    {
        //        Log.Info(flowId, "webSocket:连接失败!");
        //        return default;
        //    }
        //    Log.Info(flowId, "webSocket:连接成功!");

        //    ScadaDispatchOutput output = null;
        //    var inputJson = JsonHelper.Object2FormatJson(input);
        //    Log.Debug(flowId, inputJson);
        //    var inputBytes = Encoding.UTF8.GetBytes(inputJson);
        //    await ws.SendAsync(inputBytes, WebSocketMessageType.Text, true, CancellationToken.None);
        //    try
        //    {
        //        var buffer = new ArraySegment<byte>(new byte[1024 * 4]);
        //        WebSocketReceiveResult result = null;
        //        using (var ms = new MemoryStream())
        //        {
        //            do
        //            {
        //                result = await ws.ReceiveAsync(buffer, CancellationToken.None);
        //                ms.Write(buffer.Array, buffer.Offset, result.Count);
        //            }
        //            while (!result.EndOfMessage);

        //            ms.Seek(0, SeekOrigin.Begin);
        //            if (result.MessageType == WebSocketMessageType.Text && !result.CloseStatus.HasValue)
        //            {
        //                using (var reader = new StreamReader(ms, Encoding.UTF8))
        //                {
        //                    string outputJson = reader.ReadToEnd();
        //                    output = new ScadaDispatchOutput();
        //                    output.Scadas = JsonHelper.Json2Object<Dictionary<string, Dictionary<DateTime, string>>>(outputJson);
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        Log.Error(flowId, ex.Message);
        //    }
        //    finally
        //    {
        //        try
        //        {
        //            //关闭WebSocket
        //            await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "AcknowledgeCloseframe", CancellationToken.None);
        //        }
        //        catch (Exception ex)
        //        {
        //            Log.Error(flowId, "关闭WebSocket异常", ex);
        //        }
        //        ws.Abort();
        //        ws.Dispose();
        //    }

        //    return output;
        //}

        ///// <summary>
        ///// 创建客户端实例
        ///// </summary> 
        ///// <returns></returns>
        //public static async Task<ClientWebSocket> CreateAsync(string ServerUri)
        //{
        //    var webSocket = new ClientWebSocket();
        //    webSocket.Options.RemoteCertificateValidationCallback = delegate { return true; };

        //    await webSocket.ConnectAsync(new Uri(ServerUri), CancellationToken.None);
        //    if (webSocket.State == WebSocketState.Open)
        //    {
        //        return webSocket;
        //    }
        //    return null;
        //}


    }
}