#region    [自定义类-VS][20250701112200484][AutoThread]
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using GZ.Modular.Redis;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
using System.Windows.Interop;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TextBox;
using System.Security.Cryptography;
using System.Windows.Markup;
using static System.Runtime.CompilerServices.RuntimeHelpers;
using ServiceStack.Configuration;
using ServiceStack;
using static Dapper.SqlMapper;
using System.IO;
using System.Net.WebSockets;
using System.Net;
using System.Threading;
using System.Net.Sockets;
using NLog.Config;
using NLog.Targets;
using NLog;
using ServiceStack.Messaging.Rcon;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Security.RightsManagement;
using static GZ.Projects.HnSx.Clloc.sendTask;
using static GZ.Projects.HnSx.Clloc.modifyTaskPriority;
using static GZ.Projects.HnSx.Clloc.stockInException;
using static GZ.Projects.HnSx.Clloc.taskFeedback;
using static GZ.Projects.HnSx.Clloc.stockInInteraction;
using static GZ.Projects.HnSx.Clloc.cancelTask;
using static GZ.Projects.HnSx.Clloc.palletStackerInteraction;
using static GZ.Projects.HnSx.Clloc.putConveyorTask;
using static GZ.Projects.HnSx.Clloc.reportWeightinfo;
using System.Threading.Channels;
using static GZ.Projects.HnSx.Clloc;

namespace GZ.Projects.HnSx
{
    public partial class AutoThread
    {

        private static AutoThread _instance;

        // 私有构造函数防止外部实例化
        private AutoThread() { }

        public static AutoThread Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new AutoThread();
                }
                return _instance;
            }
        }

        // 线程安全的委托缓存
        private static readonly ConcurrentDictionary<string, Delegate> _methodCache = new ConcurrentDictionary<string, Delegate>();

        // 方法执行器
        public static object InvokeMethod(object instance, string methodName, params object[] args)
        {
            var cacheKey = $"{instance.GetType().FullName}_{methodName}";

            if (!_methodCache.TryGetValue(cacheKey, out var methodDelegate))
            {
                // 获取方法信息
                var methodInfo = instance.GetType().GetMethod(
                    methodName,
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

                if (methodInfo == null)
                    throw new MissingMethodException($"Method {methodName} not found");

                // 创建委托并缓存
                methodDelegate = Delegate.CreateDelegate(
                    GetDelegateType(methodInfo),
                    instance,
                    methodInfo);

                _methodCache.TryAdd(cacheKey, methodDelegate);
            }

            // 执行委托
            return methodDelegate.DynamicInvoke(args);
        }

        // 根据方法签名生成对应的委托类型
        private static Type GetDelegateType(MethodInfo methodInfo)
        {
            var parameterTypes = methodInfo.GetParameters()
                .Select(p => p.ParameterType)
                .ToList();

            if (methodInfo.ReturnType == typeof(void))
            {
                return System.Linq.Expressions.Expression.GetActionType(parameterTypes.ToArray());
            }
            else
            {
                parameterTypes.Add(methodInfo.ReturnType);
                return System.Linq.Expressions.Expression.GetFuncType(parameterTypes.ToArray());
            }
        }

        /// <summary>
        /// 配置初始化。
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="action"></param>
        public void ThreadSettingInit(Tag tag)
        {
        }

        public async void ThreadwebSoc()
        {
            //read Alldata from database
            //将数据缓存到内存。
            try
            {
                Thread.Sleep(1000);
                while (true)
                {
                    if (/*list.Count > 0 && */WebSocketClientWithReconnect.GetWebSocketState() == WebSocketState.Open)
                        for (int i = 0; i < 70000; i++)
                        {
                            Thread.Sleep(1000);
                            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")}>>>发送 第 {i} 条");
                            //LogHelper.Info($"Hello Server {i}");
                            var req = new ReportWeightInfoRequest
                            {
                                data = new ReportWeightInfoData
                                {
                                    header = new ReportWeightInfoHeader
                                    {
                                        deliveryNo = "F0000" + i,
                                        grossWeight = i,
                                        cube = i,
                                        addTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"),
                                        addWho = "WCS"
                                    }
                                }
                            };
                            var b = WebSocketClientWithReconnect.Instance?.SendAsync(JsonConvert.SerializeObject(req)).Result;
                            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")}>>发送完成！！" + b);
                            if (b == true)
                            {
                                // 等待特定响应

                                var rr = reportWeightinfo.GetChinnnl().Result;

                                //LogHelper.Info($" {DateTime.Now.ToString("HH:mm:ss.fff")}>> 接收" + JsonConvert.SerializeObject(rr));
                                //}
                                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")}>>" + JsonConvert.SerializeObject(rr));
                            }
                            else Console.WriteLine("发送失败。");
                        }
                    Thread.Sleep(1000);
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex.Message, ex);
            }
        }
        public async Task TaskEverythingRun()
        {
            var host = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
            foreach (var ip in host.AddressList)
            {
                if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    Console.WriteLine($"ip= {ip.ToString()}");
                    new HttpServer(ip.ToString()).HttpServerRun();
                    //new TcpServer(ip.ToString());
                    //var server = new EnhancedWebSocketServer($"http://{ip.ToString()}:8809/").StartAsync(); http://10.20.66.121:18080
                    new WebSocketClientWithReconnect($"ws://10.20.66.121:20001/socket").StartAsync();
                    //new WebSocketClientWithReconnect($"ws://{ip.ToString()}:8809/socket").StartAsync();
                    WebSocketClientWithReconnect.Instance.OnMessageReceived += (msg) =>
                    {
                        //reportWeightinfo.channel.Writer.TryWrite(JsonConvert.DeserializeObject<ReportWeightInfoResponse>(msg));
                        reportWeightinfo.channel.Writer.TryWrite(new ReportWeightInfoResponse
                        {
                            Response = new ReportWeightInfoResponseData
                            {
                                Return = new ReportWeightInfoReturnInfo
                                {
                                    returnCode = "0000",
                                    sortingChute = msg
                                }
                            }
                        });
                    };
                    break;
                }
            }
        }



    }
    public class HttpServer
    {
        public static readonly HttpHelper apiHelper = new HttpHelper();
        System.Net.HttpListener HttpSvcHost = null;

        public static string _listenerPrefix = "";
        public HttpServer(string ip)
        {
            _listenerPrefix = $"http://{ip}:8808/";
        }
        public void HttpServerRun()
        {
            HttpSvcHost = new System.Net.HttpListener();
            HttpSvcHost.AuthenticationSchemes = System.Net.AuthenticationSchemes.Anonymous;
            HttpSvcHost.Prefixes.Add(_listenerPrefix);
            HttpSvcHost.Start();
            HttpSvcHost.BeginGetContext(HttpSvcListenerCallback, null);
        }

        private async void HttpSvcListenerCallback(IAsyncResult ar)
        {
            System.Net.HttpListenerContext context = null;
            var data = DateTime.Now;
            string apth = "";
            try
            {
                HttpSvcHost.BeginGetContext(HttpSvcListenerCallback, null);
                context = HttpSvcHost.EndGetContext(ar);
                System.Net.HttpListenerRequest request = context.Request;
                System.Net.HttpListenerResponse response = context.Response;

                using (var reader = new System.IO.StreamReader(request.InputStream, System.Text.Encoding.UTF8))
                {
                    string requestJson = reader.ReadToEnd();
                    System.Net.HttpStatusCode statusCode = 0;
                    apth = request.Url.AbsolutePath;
                    string respstr = HttpSvcListenerCallback_he(request.HttpMethod, request.Url.AbsolutePath, requestJson, out statusCode);
                    string logContent = "";
                    logContent += $"\r\n[{request.HttpMethod}]{request.Url.AbsolutePath}";
                    logContent += $"\r\n[request]{requestJson}";
                    logContent += $"\r\n[response]{respstr}";
                    _ = Task.Run(() =>
                    {
                        LogHelper.Info(logContent);
                        Conn.log默认日志?.Info(logContent);
                    });
                    byte[] bytstr = Encoding.UTF8.GetBytes(respstr);
                    response.StatusCode = (int)statusCode;
                    response.SendChunked = false;
                    response.ContentLength64 = bytstr.Length;
                    if (request.Url.AbsolutePath.ToLower().Contains(".js"))
                        response.ContentType = "application/javascript";
                    else if (request.Url.AbsolutePath.ToLower().Contains(".svg"))
                        response.ContentType = "image/svg+xml";
                    // 异步写入响应
                    await response.OutputStream.WriteAsync(bytstr, 0, bytstr.Length);
                }
            }
            catch (Exception ex)
            {
                _ = Task.Run(() =>
                {
                    Conn.log默认日志.Error(ex.ToString());
                });
            }
            finally
            {
                context?.Response.Close();
                Console.WriteLine(apth + "<<>>" + DateTime.Now.Subtract(data).TotalMilliseconds);
            }
        }
        public static List<SendTaskHeader> lstr = new List<SendTaskHeader>();
        public static List<PutConveyorTaskHeader> putConveyorTasks = new List<PutConveyorTaskHeader>();

        private System.String HttpSvcListenerCallback_he(System.String method, System.String path, System.String requestJson, out System.Net.HttpStatusCode statusCode)
        {
            try
            {
                switch (method)
                {
                    case "POST":
                        {
                            switch (path)
                            {
                                case "/api/Wcs/GetTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        return JsonConvert.SerializeObject(new
                                        {
                                            出入移库任务 = lstr,
                                            箱体分发任务 = putConveyorTasks
                                        });
                                        break;
                                    }
                                case "/api/Wcs/RemoveTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        lstr.RemoveAll(x => x.palletId == requestJson);
                                        putConveyorTasks.RemoveAll(x => x.palletId == requestJson);
                                        break;
                                    }
                                ///任务下发--WMS-->WC
                                case "/api/Wcs/sendTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var req = JsonConvert.DeserializeObject<SendTaskRequest>(requestJson);
                                        if (req == null || req.data == null || lstr.Find(x => x.groupTaskSequence == req.data.header.groupTaskSequence && x.groupTaskId == req.data.header.groupTaskId) != null)
                                        {
                                            if (req == null || req.data == null)

                                                return JsonConvert.SerializeObject(new SendTaskResponse
                                                {
                                                    Response = new ResponseData
                                                    {
                                                        Return = new ReturnInfo
                                                        {
                                                            returnCode = "0001",
                                                            returnDesc = req?.data == null ? "无任务下发！" : "任务重复下发！",
                                                            returnFlag = "0"
                                                        }
                                                    }
                                                });
                                            else
                                                return JsonConvert.SerializeObject(new SendTaskResponse
                                                {
                                                    Response = new ResponseData
                                                    {
                                                        Return = new ReturnInfo
                                                        {
                                                            returnCode = "0000",
                                                            returnDesc = "任务重复下发！",
                                                            returnFlag = "1"
                                                        }
                                                    }
                                                });
                                        }
                                        lstr.Add(req.data.header);
                                        return JsonConvert.SerializeObject(new SendTaskResponse
                                        {
                                            Response = new ResponseData
                                            {
                                                Return = new ReturnInfo
                                                {
                                                    returnCode = "0000",
                                                    returnDesc = "ok",
                                                    returnFlag = "1"
                                                }
                                            }
                                        });
                                    }
                                ///入库异常上报。 WCS-->WMS
                                case "/api/Wcs/stockInException":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var f = string.IsNullOrEmpty(requestJson) ? lstr.FirstOrDefault() : lstr.Find(x => x.palletId == requestJson);
                                        var str = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=STOCKINEXCEP", JsonConvert.SerializeObject(new StockInExceptionRequest
                                        {
                                            data = new StockInExceptionData
                                            {
                                                header = new StockInExceptionHeader
                                                {
                                                    organizationId = f.organizationId,
                                                    warehouseId = f.warehouseId,
                                                    groupTaskId = f.groupTaskId,
                                                    groupTaskSequence = f.groupTaskSequence,
                                                    palletId = f.palletId,
                                                    addTime = f.addTime.ToString("yyyy-MM-dd HH:mm:ss"),
                                                    addWho = f.addWho,
                                                    reason = "库位有货不可用",
                                                    reasonCode = "01"
                                                }
                                            }
                                        }));

                                        var strres = JsonConvert.DeserializeObject<StockInExceptionResponse>(str);
                                        if (strres.Response.Return.returnCode == "0000")
                                        {
                                            f.toPosition = strres.Response.Return.toPosition;
                                            f.toLocation = strres.Response.Return.toLocation;
                                        }
                                        return str;
                                    }
                                ///任务状态反馈  WCS-->WM
                                case "/api/Wcs/taskFeedback":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        //foreach (var statu in new List<string> { "", "" })
                                        {
                                            var f = string.IsNullOrEmpty(requestJson) ? lstr.FirstOrDefault() : lstr.Find(x => x.palletId == requestJson);
                                            var str = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=TASKFEEDBACK", JsonConvert.SerializeObject(new TaskFeedbackRequest
                                            {
                                                data = new TaskFeedbackData
                                                {
                                                    header = new TaskFeedbackHeader
                                                    {
                                                        organizationId = f.organizationId,
                                                        warehouseId = f.warehouseId,
                                                        groupTaskId = f.groupTaskId,
                                                        groupTaskSequence = f.groupTaskSequence,
                                                        palletId = f.palletId,
                                                        fmLocation = f.fmLocation,
                                                        fmPosition = f.fmPosition,
                                                        toLocation = f.toLocation,
                                                        toPosition = f.toPosition,
                                                        taskStatus = "80",
                                                        taskType = f.taskType,
                                                        closeTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                                                        closeWho = f.addWho
                                                    }
                                                }
                                            }));
                                        }
                                        return JsonConvert.SerializeObject("");
                                    }
                                ///入库交互  。WCS-->WMS
                                case "/api/Wcs/stockInInteraction":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var req = JsonConvert.DeserializeObject<StockInInteractionRequest>(requestJson);

                                        var str = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=STOCKININTERACTION", requestJson);
                                        //var str = @"{""Response"":{""return"":{""returnCode"":""0000"",""returnDesc"":""Success"",""returnFlag"":""1"",""groupTaskId"":""GT250708000001"",""groupTaskSequence"":""1"",""taskStatus"":""00"",""taskType"":""PA"",""priority"":""3"",""toLocation"":""5A070101"",""toPosition"":""01""}}}";
                                        var res = JsonConvert.DeserializeObject<StockInInteractionResponse>(str);
                                        if (res.Response.Return.returnCode == "0000")
                                        {
                                            var from = req.data.header;
                                            var resss = res.Response.Return;
                                            lstr.Add(new SendTaskHeader
                                            {
                                                groupTaskId = resss.groupTaskId,
                                                groupTaskSequence = resss.groupTaskSequence,
                                                fmLocation = from.fmLocation,
                                                fmPosition = from.fmPosition,
                                                palletId = from.palletId,
                                                taskStatus = resss.taskStatus,
                                                taskType = resss.taskType,
                                                priority = resss.priority,
                                                toLocation = resss.toLocation,
                                                toPosition = resss.toPosition,
                                                addTime = DateTime.Now,
                                                addWho = from.addWho,
                                            });
                                        }
                                        return str;// + JsonConvert.SerializeObject(lstr);
                                        var str1 = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=STOCKININTERACTION", JsonConvert.SerializeObject(new StockInInteractionRequest
                                        {
                                            data = new StockInInteractionData
                                            {
                                                header = new StockInInteractionHeader
                                                {
                                                    palletId = "TP9901",
                                                    grossWeight = 99,
                                                    palletWidth = 99,
                                                    fmLocation = "",
                                                    fmPosition = "",
                                                    addTime = DateTime.Now,
                                                    addWho = ""
                                                }
                                            }
                                        }));
                                        return str1;
                                    }
                                ///入库交互  。WCS-->WMS
                                case "/api/Wcs/stockInInteraction2":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var req = JsonConvert.DeserializeObject<StockInInteractionRequest>(requestJson);

                                        var str = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=STOCKININTERACTION", requestJson);
                                        //var str = @"{""Response"":{""return"":{""returnCode"":""0000"",""returnDesc"":""Success"",""returnFlag"":""1"",""groupTaskId"":""GT250708000001"",""groupTaskSequence"":""1"",""taskStatus"":""00"",""taskType"":""PA"",""priority"":""3"",""toLocation"":""5A070101"",""toPosition"":""01""}}}";
                                        var res = JsonConvert.DeserializeObject<StockInInteractionResponse>(str);
                                        if (res.Response.Return.returnCode == "0000")
                                        {
                                            var from = req.data.header;
                                            var resss = res.Response.Return;
                                            lstr.Add(new SendTaskHeader
                                            {
                                                groupTaskId = resss.groupTaskId,
                                                groupTaskSequence = resss.groupTaskSequence,
                                                fmLocation = from.fmLocation,
                                                fmPosition = from.fmPosition,
                                                palletId = from.palletId,
                                                taskStatus = resss.taskStatus,
                                                taskType = resss.taskType,
                                                priority = resss.priority,
                                                toLocation = resss.toLocation,
                                                toPosition = resss.toPosition,
                                                addTime = DateTime.Now,
                                                addWho = from.addWho,
                                            });
                                        }
                                        return str;// + JsonConvert.SerializeObject(lstr);
                                        var str1 = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=STOCKININTERACTION", JsonConvert.SerializeObject(new StockInInteractionRequest
                                        {
                                            data = new StockInInteractionData
                                            {
                                                header = new StockInInteractionHeader
                                                {
                                                    palletId = "TP9901",
                                                    grossWeight = 99,
                                                    palletWidth = 99,
                                                    fmLocation = "",
                                                    fmPosition = "",
                                                    addTime = DateTime.Now,
                                                    addWho = ""
                                                }
                                            }
                                        }));
                                        return str1;
                                    }

                                ///任务取消。 WMS-->WCS
                                case "/api/Wcs/cancelTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var req = JsonConvert.DeserializeObject<CancelTaskRequest>(requestJson);
                                        var task = lstr.Find(x => x.groupTaskId == req.data.header.groupTaskId && x.groupTaskSequence == req.data.header.groupTaskSequence);
                                        if (task == null)
                                            return JsonConvert.SerializeObject(new CancelTaskResponse
                                            {
                                                Response = new ResponseData
                                                {
                                                    Return = new ReturnInfo
                                                    {
                                                        returnCode = "0001",
                                                        returnDesc = "任务不存在！！！",
                                                        returnFlag = "0"
                                                    }
                                                }
                                            });
                                        lstr.Remove(task);
                                        return JsonConvert.SerializeObject(new CancelTaskResponse
                                        {
                                            Response = new ResponseData
                                            {
                                                Return = new ReturnInfo
                                                {
                                                    returnCode = "0000",
                                                    returnDesc = "",
                                                    returnFlag = "1"
                                                }
                                            }
                                        });
                                    }
                                /// 碟盘机申请任务。  WCS-->WMS
                                case "/api/Wcs/palletStackerInteraction":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;

                                        var str = apiHelper.Post("http://10.20.66.121:18080/datahubjson/wcs/?method=PALLETSTACKERINTERACTION", !string.IsNullOrEmpty(requestJson) ? requestJson : JsonConvert.SerializeObject(new PalletStackerInteractionRequest
                                        {
                                            data = new PalletStackerInteractionData
                                            {
                                                header = new PalletStackerInteractionHeader
                                                {
                                                    palletId = "TP9901",
                                                    taskId = $"X{DateTime.Now.ToString("yyyyMMdd")}001",
                                                    taskType = "PI",
                                                    fmLocation = "2FC1076",
                                                    addTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                                                    addWho = "wcs"
                                                }
                                            }
                                        }));
                                        return str;
                                        //return JsonConvert.SerializeObject("");
                                    }
                                ///修改任务优先级 。 WMS - WCS
                                case "/api/Wcs/modifyTaskPriority":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var req = JsonConvert.DeserializeObject<ModifyTaskPriorityRequest>(requestJson);
                                        List<TaskErrorInfo> taskErrorInfos = new List<TaskErrorInfo>();
                                        if (req != null)
                                        {
                                            foreach (var item in req.data.header)
                                            {
                                                var task = lstr.Find(x => x.groupTaskSequence == item.groupTaskSequence && x.groupTaskId == item.groupTaskId);
                                                if (task != null)
                                                {
                                                    task.priority = item.priority;
                                                }
                                                else
                                                {
                                                    taskErrorInfos.Add(new TaskErrorInfo
                                                    {
                                                        groupTaskId = item.groupTaskId,
                                                        groupTaskSequence = item.groupTaskSequence,
                                                        errorCode = "0001",
                                                        errorDesc = "没这个任务"
                                                    });
                                                }
                                            }

                                        }

                                        if (req == null || req.data.header.Count == taskErrorInfos.Count)
                                            return JsonConvert.SerializeObject(new ModifyTaskPriorityResponse
                                            {
                                                Response = new ModifyTaskPriorityResponseData
                                                {
                                                    Return = new ModifyTaskPriorityReturnInfo
                                                    {
                                                        returnCode = "0001",
                                                        returnDesc = "没有任务可更改",
                                                        returnFlag = "0"
                                                    }
                                                }
                                            });
                                        else
                                        {
                                            if (taskErrorInfos.Count == 0)
                                                return JsonConvert.SerializeObject(new ModifyTaskPriorityResponse
                                                {
                                                    Response = new ModifyTaskPriorityResponseData
                                                    {
                                                        Return = new ModifyTaskPriorityReturnInfo
                                                        {
                                                            returnCode = "0000",
                                                            returnFlag = "1"
                                                        }
                                                    }
                                                });
                                            else
                                            {
                                                return JsonConvert.SerializeObject(new ModifyTaskPriorityResponse
                                                {
                                                    Response = new ModifyTaskPriorityResponseData
                                                    {
                                                        Return = new ModifyTaskPriorityReturnInfo
                                                        {
                                                            returnCode = "0001",
                                                            returnDesc = "部分任务可更改",
                                                            returnFlag = "2",
                                                            resultInfo = taskErrorInfos
                                                        }
                                                    }
                                                });
                                            }
                                        }

                                    }
                                /// 输送线任务推送。 WMS-->WCS  -- 记录箱号数据，分拣下线后根据想好进入对应的区域。 
                                case "/api/Wcs/putConveyorTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        var req = JsonConvert.DeserializeObject<PutConveyorTaskRequest>(requestJson);
                                        List<TaskErrorInfo> taskErrorInfos = new List<TaskErrorInfo>();
                                        if (req != null)
                                        {
                                            foreach (var item in req.data.header)
                                            {
                                                var task = putConveyorTasks.Find(x => x.groupTaskSequence == item.groupTaskSequence && x.groupTaskId == item.groupTaskId);
                                                if (task == null)
                                                {
                                                    putConveyorTasks.Add(item);
                                                }
                                                else
                                                {
                                                    taskErrorInfos.Add(new TaskErrorInfo
                                                    {
                                                        groupTaskId = item.groupTaskId,
                                                        groupTaskSequence = item.groupTaskSequence,
                                                        errorCode = "0001",
                                                        errorDesc = "重复"
                                                    });
                                                }
                                            }

                                        }

                                        if (req == null || req.data.header.Count == taskErrorInfos.Count)
                                            return JsonConvert.SerializeObject(new PutConveyorTaskResponse
                                            {
                                                Response = new PutConveyorTaskResponseData
                                                {
                                                    Return = new PutConveyorTaskReturnInfo
                                                    {
                                                        returnCode = "0001",
                                                        returnDesc = "全部重复",
                                                        returnFlag = "0"
                                                    }
                                                }
                                            });
                                        else
                                        {
                                            if (taskErrorInfos.Count == 0)
                                                return JsonConvert.SerializeObject(new PutConveyorTaskResponse
                                                {
                                                    Response = new PutConveyorTaskResponseData
                                                    {
                                                        Return = new PutConveyorTaskReturnInfo
                                                        {
                                                            returnCode = "0000",
                                                            returnFlag = "1"
                                                        }
                                                    }
                                                });
                                            else
                                            {
                                                return JsonConvert.SerializeObject(new PutConveyorTaskResponse
                                                {
                                                    Response = new PutConveyorTaskResponseData
                                                    {
                                                        Return = new PutConveyorTaskReturnInfo
                                                        {
                                                            returnCode = "0001",
                                                            returnDesc = "部分重复",
                                                            returnFlag = "2",
                                                            resultInfo = taskErrorInfos
                                                        }
                                                    }
                                                });
                                            }
                                        }
                                    }

                                ///上报称重尺寸 - websocket .这里写着作为记录 
                                case "/api/Wcs/reportWeightinfo":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        if (/*list.Count > 0 && */WebSocketClientWithReconnect.GetWebSocketState() == WebSocketState.Open)
                                        //for (int i = 60000; i < 70000; i++)
                                        {
                                            //Thread.Sleep(1000);
                                            var req = new ReportWeightInfoRequest
                                            {
                                                data = new ReportWeightInfoData
                                                {
                                                    header = new ReportWeightInfoHeader
                                                    {
                                                        deliveryNo = "F00001",
                                                        grossWeight = 99,
                                                        cube = 66,
                                                        addTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"),
                                                        addWho = "WCS"
                                                    }
                                                }
                                            };
                                            //Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")}>>>GGG{i}");
                                            LogHelper.Info(JsonConvert.SerializeObject(req));
                                            var b = WebSocketClientWithReconnect.Instance?.SendAsync(JsonConvert.SerializeObject(req)).Result;
                                            Console.WriteLine(req.data.header.deliveryNo + "发送完成！！" + b);
                                            if (b == true)
                                            {
                                                // 等待特定响应

                                                var rr = reportWeightinfo.GetChinnnl().Result;

                                                LogHelper.Info("接收" + JsonConvert.SerializeObject(rr));
                                                //}
                                                return JsonConvert.SerializeObject(rr);
                                            }
                                            else return "发送失败。";
                                        }
                                    }
                                    break;
                            }
                            break;
                        }
                    case "GET":
                        {
                            switch (path)
                            {
                                case var _ when System.Text.RegularExpressions.Regex.IsMatch(path, @"\.(html|ico|js|css)(\?.*)?$", System.Text.RegularExpressions.RegexOptions.IgnoreCase):
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        // 复制到case 上
                                        //var _ when System.Text.RegularExpressions.Regex.IsMatch(path, @"\.(html|ico|js|css)(\?.*)?$", System.Text.RegularExpressions.RegexOptions.IgnoreCase)
                                        var filePath = /*Directory.GetCurrentDirectory() + "\\Static" + "\\" + path.Substring(1);*/System.IO.Path.Combine(Directory.GetCurrentDirectory() + "\\Static", path.Substring(1));
                                        return File.ReadAllText(filePath);
                                    }
                            }
                            break;
                        }
                }
                statusCode = System.Net.HttpStatusCode.NotFound;
                return "";
            }
            catch (Exception ex)
            {
                Conn.log默认日志.Error(ex.ToString());
                statusCode = System.Net.HttpStatusCode.InternalServerError;
                return "";
            }
        }
    }

    class EnhancedWebSocketServer
    {
        private HttpListener _listener;
        private readonly string _listenerPrefix;
        private readonly ConcurrentDictionary<Guid, WebSocket> _connections = new ConcurrentDictionary<Guid, WebSocket>();
        private CancellationTokenSource _cts = new CancellationTokenSource();

        public EnhancedWebSocketServer(string url)
        {
            _listenerPrefix = url;
        }

        public async Task StartAsync()
        {
            try
            {
                _listener = new HttpListener();
                _listener.Prefixes.Add(_listenerPrefix);
                _listener.Start();
                Console.WriteLine($"WebSocket服务器已启动，监听 {_listenerPrefix}");
                while (!_cts.IsCancellationRequested)
                {
                    HttpListenerContext context = await _listener.GetContextAsync();
                    if (context.Request.IsWebSocketRequest)
                    {
                        var wsContext = await context.AcceptWebSocketAsync(null);
                        var connectionId = Guid.NewGuid();
                        _connections[connectionId] = wsContext.WebSocket;
                        _ = HandleConnectionAsync(connectionId, wsContext.WebSocket, _cts.Token);
                    }
                    else
                    {
                        context.Response.StatusCode = 400;
                        context.Response.Close();
                    }
                }
            }
            catch (Exception ex) when (ex is HttpListenerException || ex is ObjectDisposedException)
            {
                // 服务器停止时的正常异常
                Console.WriteLine("服务器正在停止...");
            }
        }

        private async Task HandleConnectionAsync(Guid connectionId, WebSocket webSocket, CancellationToken ct)
        {
            var buffer = new byte[1024 * 4];
            try
            {
                while (webSocket.State == WebSocketState.Open && !ct.IsCancellationRequested)
                {
                    var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), ct);

                    if (result.MessageType == WebSocketMessageType.Close)
                    {
                        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "客户端关闭连接", ct);
                        break;
                    }

                    string message = System.Text.Encoding.UTF8.GetString(buffer, 0, result.Count);
                    Console.WriteLine($"连接 {connectionId} 收到消息: {message}");

                    // 广播消息给所有客户端
                    await BroadcastMessageAsync($"客户端 {connectionId} 说: {message}");
                }
            }
            catch (WebSocketException ex)
            {
                Console.WriteLine($"连接 {connectionId} 错误: {ex.WebSocketErrorCode} - {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"处理连接 {connectionId} 时出错: {ex.Message}");
            }
            finally
            {
                _connections.TryRemove(connectionId, out _);
                webSocket?.Dispose();
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")} 连接 {connectionId} 已关闭");
            }
        }

        public async Task BroadcastMessageAsync(string message)
        {
            var buffer = System.Text.Encoding.UTF8.GetBytes(message);
            foreach (var connection in _connections)
            {
                if (connection.Value.State == WebSocketState.Open)
                {
                    try
                    {
                        await connection.Value.SendAsync(
                            new ArraySegment<byte>(buffer),
                            WebSocketMessageType.Text,
                            true,
                            CancellationToken.None);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"广播消息到连接 {connection.Key} 失败: {ex.Message}");
                    }
                }
            }
        }

        public async Task StopAsync()
        {
            _cts.Cancel();

            // 关闭所有连接
            foreach (var connection in _connections)
            {
                try
                {
                    if (connection.Value.State == WebSocketState.Open)
                    {
                        await connection.Value.CloseAsync(
                            WebSocketCloseStatus.NormalClosure,
                            "服务器关闭",
                            CancellationToken.None);
                    }
                    connection.Value.Dispose();
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"关闭连接 {connection.Key} 时出错: {ex.Message}");
                }
            }

            _listener?.Stop();
            _listener?.Close();
            Console.WriteLine("WebSocket服务器已停止");
        }

    }

    public class WebSocketClientWithReconnect
    {
        //public static List<object> SendList = new List<object>();

        public static ClientWebSocket _webSocket;
        private static WebSocketClientWithReconnect _instance;
        private readonly Uri _serverUri;
        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
        private readonly int _reconnectDelayMs;

        public event Action<string> OnMessageReceived = msg => Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")}>>>Received: {msg}");
        public event Action OnConnected = () => Console.WriteLine("Connected to server");
        public event Action OnDisconnected = () => Console.WriteLine("Disconnected from webSocket server");
        public event Action<Exception> OnError = ex => Console.WriteLine($"Error: {ex.Message}");

        public WebSocketClientWithReconnect(string serverUrl, int reconnectDelayMs = 5000)
        {
            _serverUri = new Uri(serverUrl);
            _reconnectDelayMs = reconnectDelayMs;
        }
        public static WebSocketClientWithReconnect Instance
        {
            get
            {
                return _instance;
            }
        }

        public static WebSocketState GetWebSocketState() => _webSocket != null ? _webSocket.State : WebSocketState.Closed;
        public async Task StartAsync()
        {
            _instance = this;
            while (!_cts.IsCancellationRequested)
            {
                try
                {
                    _webSocket = new ClientWebSocket();
                    await _webSocket.ConnectAsync(_serverUri, _cts.Token);
                    OnConnected?.Invoke();
                    await ReceiveMessagesAsync();
                }
                catch (Exception ex) when (!_cts.IsCancellationRequested)
                {
                    OnError?.Invoke(ex);
                    await HandleDisconnection();
                }
            }
        }

        private async Task ReceiveMessagesAsync()
        {
            var buffer = new byte[1024 * 4];

            while (_webSocket.State == WebSocketState.Open && !_cts.IsCancellationRequested)
            {
                try
                {
                    var result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), _cts.Token);

                    if (result.MessageType == WebSocketMessageType.Close)
                    {
                        await HandleDisconnection();
                        break;
                    }

                    var message = System.Text.Encoding.UTF8.GetString(buffer, 0, result.Count);
                    OnMessageReceived?.Invoke(message);
                }
                catch (Exception ex) when (!_cts.IsCancellationRequested)
                {
                    OnError?.Invoke(ex);
                    await HandleDisconnection();
                    break;
                }
            }
        }

        private async Task HandleDisconnection()
        {
            OnDisconnected?.Invoke();

            try
            {
                if (_webSocket != null && _webSocket.State != WebSocketState.Closed)
                {
                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
                    _webSocket.Dispose();
                }
            }
            catch { /* 忽略关闭时的异常 */ }

            if (!_cts.IsCancellationRequested)
            {
                await Task.Delay(_reconnectDelayMs, _cts.Token);
            }
        }

        public async Task StopAsync()
        {
            _cts.Cancel();

            try
            {
                if (_webSocket != null && _webSocket.State == WebSocketState.Open)
                {
                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Client shutdown", CancellationToken.None);
                }
            }
            finally
            {
                _webSocket?.Dispose();
            }
        }

        public async Task<bool> SendAsync(string message)
        {
            if (_webSocket?.State != WebSocketState.Open)
            {
                throw new InvalidOperationException("WebSocket is not connected");
            }

            var bytes = System.Text.Encoding.UTF8.GetBytes(message);
            await _webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, _cts.Token);
            return true;
        }
    }

    public class TcpServer
    {
        public static Dictionary<string, string> TrayIps = new Dictionary<string, string>();
        public TcpServer(string ip)
        {
            Init(ip);
        }
        private void Init(string ip)
        {
            //创建一个新的Socket,这里我们使用最常用的基于TCP的Stream Socket（流式套接字）
            var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try
            {
                //将该socket绑定到主机上面的某个端口
                socket.Bind(new IPEndPoint(IPAddress.Parse(ip), 2025));
                Console.WriteLine($"TCPServer socket 监听{ip}:{2025} ");
                //启动监听，并且设置一个最大的队列长度
                socket.Listen(30);
                //开始接受客户端连接请求
                socket.BeginAccept(new AsyncCallback(ClientAccepted), socket);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
        public static Dictionary<string, Socket> clients = new Dictionary<string, Socket>();
        public static Dictionary<string, byte[]> buffers = new Dictionary<string, byte[]>();
        public static void ClientAccepted(IAsyncResult ar)
        {

            var socket = ar.AsyncState as Socket;
            var client = socket.EndAccept(ar);
            string remote_ip = ((System.Net.IPEndPoint)client.RemoteEndPoint).Address.ToString();
            if (clients.Keys.Contains(remote_ip))
            {
                clients[remote_ip] = client;
            }
            else
            {
                clients.Add(remote_ip, client);
            }
            if (!buffers.Keys.Contains(remote_ip))
            {
                buffers.Add(remote_ip, new byte[1024]);
            }
            //给客户端发送一个欢迎消息
            //client.Send(Encoding.Unicode.GetBytes("Hi there, I accept you request at " + DateTime.Now.ToString()));
            Console.WriteLine(remote_ip);

            try
            {
                client.BeginReceive(buffers[remote_ip], 0, buffers[remote_ip].Length, SocketFlags.None, new AsyncCallback(ReceiveMessage), client);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"【接收客户端的消息异常0】：" + ex.Message);
            }
            //准备接受下一个客户端请求
            socket.BeginAccept(new AsyncCallback(ClientAccepted), socket);
        }


        public static void ReceiveMessage(IAsyncResult ar)
        {
            try
            {
                var socket = ar.AsyncState as Socket;
                string remote_ip = ((System.Net.IPEndPoint)socket.RemoteEndPoint).Address.ToString();
                var length = socket.EndReceive(ar);
                if (length == 0)
                {
                    clients.Remove(remote_ip);
                    buffers.Remove(remote_ip);
                    return;
                }
                else
                {
                    if (!clients.Keys.Contains(remote_ip))
                    {
                        clients.Add(remote_ip, socket);
                    }
                    if (!buffers.Keys.Contains(remote_ip))
                    {
                        buffers.Add(remote_ip, new byte[1024]);
                    }
                }
                try
                {
                    if (buffers.Keys.Contains(remote_ip))
                    {
                        //读取出来消息内容
                        var message = GetHexString(buffers[remote_ip], length);
                        //16   10
                        // Console.WriteLine($"{DateTime.Now.ToString("hh:mm:ss")} ---> " + remote_ip + "  :   " + message);
                        //if (message.Substring(0, 4) == "3f00" && message.Substring(message.Length - 4) == "0d0a")
                        //{
                        //    //显示消息
                        //    //string msg = message.Replace(@"0d", "").Replace(@"0a", "").Replace(@"0d0a", "").Trim();
                        //    //PlcHelper.Receive(remote_ip, msg);
                        //    //Array.Clear(buffers[remote_ip], 0, buffers[remote_ip].Length);//清空当前IP Buffer
                        //}
                        //else
                        //{
                        Console.WriteLine($"【TCP信息协议 {DateTime.Now.Millisecond}】：IP：{remote_ip},MSG：{message}");
                        var mg = message;// Encoding.ASCII.GetString(PlcHelper.Hex2Bin(message));
                        if (mg.Length > 10)
                        {
                            mg = mg.Substring(0, 10);
                        }
                        Console.WriteLine(mg);
                        if (mg.StartsWith("DK"))//&& mg.Trim().Length == "DK01000024".Length
                        {
                            LogHelper.Info($"扫码器 >{remote_ip} -{mg}");
                            if (TrayIps.TryGetValue(remote_ip, out string traycode))
                            {
                                TrayIps[remote_ip] = mg;
                            }
                            else TrayIps.Add(remote_ip, mg);

                            RedisHelper.Add("S扫码器" + (remote_ip.Split('.').LastOrDefault()), mg, out string msg);
                            RedisHelper.Add("S扫码器" + (remote_ip.Split('.').LastOrDefault()) + "#time", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), out msg);
                            //Console.WriteLine("TOFF");
                            //var mst = PlcHelper.Hex2Bin("544F4646");
                            //TcpServer.TcpServerSend(remote_ip, mst);
                        }
                        //}
                    }
                    else
                    {
                        if (!buffers.Keys.Contains(remote_ip))
                        {
                            buffers.Add(remote_ip, new byte[1024]);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"【处理客户端的消息异常2】：" + ex.StackTrace);
                    throw;
                }
                //接收下一个消息(因为这是一个递归的调用，所以这样就可以一直接收消息了）
                socket.BeginReceive(buffers[remote_ip], 0, buffers[remote_ip].Length, SocketFlags.None, new AsyncCallback(ReceiveMessage), socket);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        private static string GetHexString(byte[] buffer, int lenght)
        {
            return BitConverter.ToString(buffer, 0, lenght).Replace("-", string.Empty).ToLower();
        }

        public static bool TcpServerSend(string ip, byte[] msg)
        {
            LogHelper.Info($"TcpServerSend >{ip}:{msg}");
            if (clients.Keys.Contains(ip))
            {
                var client = clients[ip];
                if (client.Connected)
                {
                    try
                    {
                        client.Send(msg);
                        LogHelper.Info($"TcpServerSend > 发送成功。");
                        return true;
                    }
                    catch (SocketException ex)
                    {
                        Console.WriteLine(ex.Message);
                        clients[ip].Close();
                        clients.Remove(ip);
                    }
                }
                else
                {
                    clients[ip].Close();
                    clients.Remove(ip);
                }
            }
            else
            {
                Console.WriteLine("未找到设备的链接：" + ip);
            }
            return false;

        }

        public static int GetBitdata(int num, int wid)
        {
            string bstr = Convert.ToString(num, 2);
            if (bstr.Length <= wid)
            {
                return 0;
            }
            return bstr[bstr.Length - wid - 1] - '0';
        }
        public static int SetBinaryDigit(int number, int n, int value)
        {
            if (value != 0 && value != 1)
                throw new ArgumentException("Value must be 0 or 1.");

            string binaryStr = Convert.ToString(number, 2);

            // 如果 n 超出当前位数，补 0 扩展
            while (binaryStr.Length <= n)
            {
                binaryStr = "0" + binaryStr;
            }

            // 修改第 n 位（从右往左，最低位是第 0 位）
            char[] binaryChars = binaryStr.ToCharArray();
            binaryChars[binaryChars.Length - 1 - n] = value == 1 ? '1' : '0';

            // 转换回十进制
            return Convert.ToInt32(new string(binaryChars), 2);
        }
        public static List<string> GetStaticClients() => clients.Keys.ToList();
        public static Dictionary<string, string> GetStaticScan() => TrayIps;
    }

    public class LogHelper
    {
        #region    [自定义类][20250323145442478][LogHelper]
        public static Dictionary<string, ILogger> loggers = new Dictionary<string, ILogger>();

        public static void Debug(string message, string name = "")
        {
            ILogger logger = null;
            if (loggers.Keys.Contains(name))
            {
                logger = loggers[name];
            }
            else
            {
                logger = LogFactory.CreateLogger(name);
                if (logger != null)
                {
                    loggers.Add(name, logger);
                }
                else
                {
                    logger = LogFactory.CreateLogger("console");
                }
            }
            if (logger != null)
            {
                logger.Debug(message);
            }
        }



        public static void Info(string message, string name = "")
        {
            //logger.Info(message);
            ILogger logger = null;
            if (loggers.Keys.Contains(name))
            {
                logger = loggers[name];
            }
            else
            {
                logger = LogFactory.CreateLogger(name);
                if (logger != null && !loggers.Keys.Contains(name))
                {
                    loggers.Add(name, logger);
                }
                else
                {
                    logger = LogFactory.CreateLogger("infoFile");
                }
            }
            if (logger != null)
            {
                logger.Info(message);
            }
        }

        public static void Error(string message, Exception ex, string name = "")
        {
            //logger.Error(ex, message);
            ILogger logger = null;
            if (loggers.Keys.Contains(name))
            {
                logger = loggers[name];
            }
            else
            {
                logger = LogFactory.CreateLogger(name);
                if (logger != null && !loggers.Keys.Contains(name))
                {
                    loggers.Add(name, logger);
                }
                else
                {
                    logger = LogFactory.CreateLogger("errorFile");
                }
            }
            if (logger != null)
            {
                logger.Error($"{message}{ex.StackTrace}");
            }
        }
        #endregion [自定义类][20250323145442478][LogHelper]
    }
    public class LogFactory
    {
        #region    [自定义类][20250323145505759][LogFactory]
        /// <summary>
        /// 通过配置文件配置日志
        /// </summary>
        static LogFactory()
        {
            var loggerNames = new List<string>() { "HosttoagvTask", "HosttoagvCar", "NDC", "杭奥" };
            LogManager.Configuration = DefaultConfig(loggerNames);
        }
        public static ILogger CreateLogger(string name)
        {
            var logger = LogManager.GetLogger(name);
            return logger;
        }

        public static LoggingConfiguration DefaultConfig(List<string> loggerNames)
        {
            var config = new LoggingConfiguration();
            loggerNames.ForEach(a =>
            {
                var target = new FileTarget();
                target.ArchiveAboveSize = 1024 * 1024 * 5;//每个文件最大5M
                target.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;
                target.ArchiveFileName = @"${basedir}/Logs/" + a + "/{####}.txt";
                target.FileName = @"${basedir}/Logs/" + a + "/${shortdate}.txt";//当前文件路径
                target.Layout = @"${longdate} | ${level:uppercase=false:padding=-5} | ${message} ${onexception:${exception:format=tostring} ${newline} ${stacktrace} ${newline}";

                config.AddTarget(a, target);
                config.AddRuleForOneLevel(LogLevel.Info, target, a);
            });


            // 添加target-console
            var consoleTarget = new ColoredConsoleTarget();
            consoleTarget.Layout = @"${longdate} | ${level:uppercase=false:padding=-5} | ${message} ${onexception:${exception:format=tostring} ${newline} ${stacktrace} ${newline}";

            config.AddTarget("console", consoleTarget);
            config.AddRule(LogLevel.Debug, LogLevel.Fatal, consoleTarget);

            //添加target-info
            var infoFileTarget = new FileTarget();
            infoFileTarget.ArchiveAboveSize = 1024 * 1024 * 5;//每个文件最大5M
            infoFileTarget.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;
            infoFileTarget.ArchiveFileName = @"${basedir}/Logs/Info/{####}.txt";
            infoFileTarget.FileName = @"${basedir}/Logs/Info/${shortdate}.txt";//当前文件路径
            infoFileTarget.Layout = @"${longdate} | ${level:uppercase=false:padding=-5} | ${message} ${onexception:${exception:format=tostring} ${newline} ${stacktrace} ${newline}";

            config.AddTarget("infoFile", infoFileTarget);
            config.AddRuleForOneLevel(LogLevel.Info, infoFileTarget);//INFO写在Info文件

            //添加target-err
            var errorFileTarget = new FileTarget();
            errorFileTarget.ArchiveAboveSize = 1024 * 1024 * 5;//每个文件最大5M
            errorFileTarget.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;
            errorFileTarget.ArchiveFileName = @"${basedir}/Logs/Error/{####}.txt";
            errorFileTarget.FileName = @"${basedir}/Logs/Error/${shortdate}.txt";
            errorFileTarget.Layout = @"${longdate} | ${level:uppercase=false:padding=-5} | ${message} ${onexception:${exception:format=tostring} ${newline} ${stacktrace} ${newline}";

            config.AddTarget("errorFile", errorFileTarget);
            config.AddRule(LogLevel.Error, LogLevel.Fatal, errorFileTarget);


            return config;
        }

        #endregion [自定义类][20250323145505759][LogFactory]
    }

    public class HttpHelper
    {
        #region    [自定义类][20250325095622918][HttpHelper]
        public string Post(string url, string postData, string contentType = "application/json", string sessionId = "")
        {
            LogHelper.Info(url + "+" + postData);
            WebRequest request = WebRequest.Create(url);
            request.Method = "POST";
            byte[] byteArray = Encoding.UTF8.GetBytes(postData);
            request.ContentType = contentType;
            request.ContentLength = byteArray.Length;
            request.Timeout = 15000;
            if (sessionId != "")
            {
                request.Headers.Set("ASP.NET_SessionId", sessionId);
            }

            //Authorization: UApGP6WW9FsBUqAlzxRGOw ==
            request.Headers.Set("Authorization", "UApGP6WW9FsBUqAlzxRGOw==");
            StreamReader reader = null;
            Stream stream = null;
            WebResponse rsp = null;
            try
            {
                stream = request.GetRequestStream();
                stream.Write(byteArray, 0, byteArray.Length);
                stream.Close();
                rsp = request.GetResponse();
                stream = rsp.GetResponseStream();
                reader = new StreamReader(stream);
                string rrend = reader.ReadToEnd();
                LogHelper.Info($"{url} response={rrend}");
                return rrend;
            }
            catch (Exception ex)
            {
                LogHelper.Info($"{url} err={ex.Message}");
                return "";
            }
            finally
            {
                // 释放资源
                if (reader != null) reader.Close();
                if (stream != null) stream.Close();
                if (rsp != null) rsp.Close();
            }

        }
        #endregion [自定义类][20250325095622918][HttpHelper]
    }
    public class Clloc
    {
        public class sendTask
        {
            /// <summary>
            /// 任务下发请求
            /// </summary>
            public class SendTaskRequest
            {
                /// <summary>
                /// 请求数据
                /// </summary>
                public SendTaskData data { get; set; }
            }

            public class SendTaskData
            {
                /// <summary>
                /// 请求头信息
                /// </summary>
                public SendTaskHeader header { get; set; }
            }

            public class SendTaskHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务组编号 - 主键
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号 - 主键
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 托盘号
                /// </summary>
                public string palletId { get; set; }

                /// <summary>
                /// 来源库位
                /// </summary>
                public string fmLocation { get; set; }

                /// <summary>
                /// 来源点位
                /// </summary>
                public string fmPosition { get; set; }

                /// <summary>
                /// 目标库位号
                /// </summary>
                public string toLocation { get; set; }

                /// <summary>
                /// 目标点位
                /// </summary>
                public string toPosition { get; set; }

                /// <summary>
                /// 状态 - 00:创建
                /// </summary>
                public string taskStatus { get; set; } = "00";

                /// <summary>
                /// 任务类型 - PA:入库(上架/回库/移库), PK:出库(拣货/移库/补货/盘点), MV:倒库
                /// </summary>
                public string taskType { get; set; }

                /// <summary>
                /// 创建时间
                /// </summary>
                public DateTime addTime { get; set; }

                /// <summary>
                /// 创建人
                /// </summary>
                public string addWho { get; set; }

                /// <summary>
                /// 优先级 - 1-5(1最高,5最低),默认3
                /// </summary>
                public string priority { get; set; } = "3";

            }

            /// <summary>
            /// 任务下发响应
            /// </summary>
            public class SendTaskResponse
            {
                public ResponseData Response { get; set; }
            }

            public class ResponseData
            {
                public ReturnInfo Return { get; set; }
            }

            public class ReturnInfo
            {
                /// <summary>
                /// 返回代码 - 0000:成功, 其他:失败
                /// </summary>
                public string returnCode { get; set; }

                /// <summary>
                /// 返回描述
                /// </summary>
                public string returnDesc { get; set; }

                /// <summary>
                /// 返回标记 - 1:成功, 0:失败
                /// </summary>
                public string returnFlag { get; set; }
            }
        }

        public class stockInException
        {
            /// <summary>
            /// 入库异常请求
            /// </summary>
            public class StockInExceptionRequest
            {
                public StockInExceptionData data { get; set; }
            }

            public class StockInExceptionData
            {
                public StockInExceptionHeader header { get; set; }
            }

            public class StockInExceptionHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务组编号 - 主键
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号 - 主键
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 托盘号
                /// </summary>
                public string palletId { get; set; }

                /// <summary>
                /// 创建时间
                /// </summary>
                public string addTime { get; set; }

                /// <summary>
                /// 创建设备
                /// </summary>
                public string addWho { get; set; }

                /// <summary>
                /// 异常原因描述
                /// </summary>
                public string reason { get; set; }

                /// <summary>
                /// 异常原因代码 - 01:库位有货不可用, 03:入内伸位外伸位有货
                /// </summary>
                public string reasonCode { get; set; }

                // ... UDF字段
            }

            /// <summary>
            /// 入库异常响应
            /// </summary>
            public class StockInExceptionResponse
            {
                public StockInExceptionResponseData Response { get; set; }
            }

            public class StockInExceptionResponseData
            {
                public StockInExceptionReturnInfo Return { get; set; }
            }

            public class StockInExceptionReturnInfo : ReturnInfo
            {
                /// <summary>
                /// 新分配的目标库位
                /// </summary>
                public string toLocation { get; set; }

                /// <summary>
                /// 新分配的目标点位
                /// </summary>
                public string toPosition { get; set; }
            }
        }

        public class taskFeedback
        {
            /// <summary>
            /// 任务反馈请求
            /// </summary>
            public class TaskFeedbackRequest
            {
                public TaskFeedbackData data { get; set; }
            }

            public class TaskFeedbackData
            {
                public TaskFeedbackHeader header { get; set; }
            }

            public class TaskFeedbackHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务组编号 - 主键
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号 - 主键
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 托盘号
                /// </summary>
                public string palletId { get; set; }

                /// <summary>
                /// 来源库位
                /// </summary>
                public string fmLocation { get; set; }

                /// <summary>
                /// 来源点位
                /// </summary>
                public string fmPosition { get; set; }

                /// <summary>
                /// 目标库位号
                /// </summary>
                public string toLocation { get; set; }

                /// <summary>
                /// 目标点位
                /// </summary>
                public string toPosition { get; set; }

                /// <summary>
                /// 状态 - 80:完成, 98:异常(取货无货)
                /// </summary>
                public string taskStatus { get; set; }

                /// <summary>
                /// 任务类型 - PA:入库, PK:出库, MV:倒库
                /// </summary>
                public string taskType { get; set; }

                /// <summary>
                /// 完成时间
                /// </summary>
                public string closeTime { get; set; }

                /// <summary>
                /// 完成人员
                /// </summary>
                public string closeWho { get; set; }

                // ... UDF字段
            }
        }
        public class stockInInteraction
        {
            /// <summary>
            /// 入库交互请求
            /// </summary>
            public class StockInInteractionRequest
            {
                public StockInInteractionData data { get; set; }
            }

            public class StockInInteractionData
            {
                public StockInInteractionHeader header { get; set; }
            }

            public class StockInInteractionHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 托盘号 - 主键
                /// </summary>
                public string palletId { get; set; }

                /// <summary>
                /// 总重量(kg)
                /// </summary>
                public decimal grossWeight { get; set; }

                /// <summary>
                /// 码盘宽度(cm)
                /// </summary>
                public decimal palletWidth { get; set; }

                /// <summary>
                /// 来源库位
                /// </summary>
                public string fmLocation { get; set; }

                /// <summary>
                /// 来源点位
                /// </summary>
                public string fmPosition { get; set; }

                /// <summary>
                /// 创建时间
                /// </summary>
                public DateTime addTime { get; set; }

                /// <summary>
                /// 创建人
                /// </summary>
                public string addWho { get; set; }

                // ... UDF01-UDF10
            }

            /// <summary>
            /// 入库交互响应
            /// </summary>
            public class StockInInteractionResponse
            {
                public StockInInteractionResponseData Response { get; set; }
            }

            public class StockInInteractionResponseData
            {
                public StockInInteractionReturnInfo Return { get; set; }
            }

            public class StockInInteractionReturnInfo : ReturnInfo
            {
                /// <summary>
                /// 任务组编号
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 状态 - 00:创建
                /// </summary>
                public string taskStatus { get; set; }

                /// <summary>
                /// 任务类型 - PA:入库
                /// </summary>
                public string taskType { get; set; }

                /// <summary>
                /// 优先级 - 1-5(1最高)
                /// </summary>
                public string priority { get; set; }

                /// <summary>
                /// 目标库位号
                /// </summary>
                public string toLocation { get; set; }

                /// <summary>
                /// 目标点位
                /// </summary>
                public string toPosition { get; set; }
            }
        }
        public class cancelTask
        {
            /// <summary>
            /// 任务取消请求
            /// </summary>
            public class CancelTaskRequest
            {
                public CancelTaskData data { get; set; }
            }

            public class CancelTaskData
            {
                public CancelTaskHeader header { get; set; }
            }

            public class CancelTaskHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务组编号 - 主键
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号 - 主键
                /// </summary>
                public int groupTaskSequence { get; set; }
            }

            /// <summary>
            /// 任务取消响应
            /// </summary>
            public class CancelTaskResponse
            {
                public ResponseData Response { get; set; }
            }
        }
        public class palletStackerInteraction
        {
            /// <summary>
            /// 叠盘机交互请求
            /// </summary>
            public class PalletStackerInteractionRequest
            {
                public PalletStackerInteractionData data { get; set; }
            }

            public class PalletStackerInteractionData
            {
                public PalletStackerInteractionHeader header { get; set; }
            }

            public class PalletStackerInteractionHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务编号 - 主键，设备发出的请求ID
                /// </summary>
                public string taskId { get; set; }

                /// <summary>
                /// 托盘号
                /// </summary>
                public string palletId { get; set; }

                /// <summary>
                /// 类型 - PI:入库, PT:出库(当前无出库场景)
                /// </summary>
                public string taskType { get; set; }

                /// <summary>
                /// 起始库位 - 叠盘机物理起始位置
                /// </summary>
                public string fmLocation { get; set; }

                /// <summary>
                /// 优先级 - 1-5(1最高)
                /// </summary>
                public string priority { get; set; } = "3";

                /// <summary>
                /// 创建时间
                /// </summary>
                public string addTime { get; set; }

                /// <summary>
                /// 创建设备
                /// </summary>
                public string addWho { get; set; }

                // ... UDF01-UDF10
            }

            /// <summary>
            /// 叠盘机交互响应
            /// </summary>
            public class PalletStackerInteractionResponse
            {
                public ResponseData Response { get; set; }
            }

        }
        public class modifyTaskPriority
        {
            /// <summary>
            /// 修改任务优先级请求
            /// </summary>
            public class ModifyTaskPriorityRequest
            {
                public ModifyTaskPriorityData data { get; set; }
            }

            public class ModifyTaskPriorityData
            {
                public List<ModifyTaskPriorityHeader> header { get; set; }
            }

            public class ModifyTaskPriorityHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务组编号 - 主键
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号 - 主键
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 优先级 - 1-5(1最高)
                /// </summary>
                public string priority { get; set; }
            }

            /// <summary>
            /// 修改任务优先级响应(支持部分成功)
            /// </summary>
            public class ModifyTaskPriorityResponse
            {
                public ModifyTaskPriorityResponseData Response { get; set; }
            }

            public class ModifyTaskPriorityResponseData
            {
                [JsonProperty("return")]
                public ModifyTaskPriorityReturnInfo Return { get; set; }
            }

            public class ModifyTaskPriorityReturnInfo : ReturnInfo
            {
                /// <summary>
                /// 部分成功时的错误详情
                /// </summary>
                public List<TaskErrorInfo> resultInfo { get; set; }
            }

            public class TaskErrorInfo
            {
                /// <summary>
                /// 任务组编号
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 错误代码
                /// </summary>
                public string errorCode { get; set; }

                /// <summary>
                /// 错误原因
                /// </summary>
                public string errorDesc { get; set; }
            }
        }
        public class putConveyorTask
        {
            /// <summary>
            /// 输送线任务推送请求
            /// </summary>
            public class PutConveyorTaskRequest
            {
                public PutConveyorTaskData data { get; set; }
            }

            public class PutConveyorTaskData
            {
                public List<PutConveyorTaskHeader> header { get; set; }
            }

            public class PutConveyorTaskHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 任务组编号 - 主键
                /// </summary>
                public string groupTaskId { get; set; }

                /// <summary>
                /// 任务组序号 - 主键
                /// </summary>
                public int groupTaskSequence { get; set; }

                /// <summary>
                /// 箱号
                /// </summary>
                public string palletId { get; set; }

                /// <summary>
                /// 箱型 - 大箱/小箱/周转箱编码
                /// </summary>
                public string palletIdType { get; set; }

                /// <summary>
                /// 贴标标记 - Y:需要贴标, N:不需要
                /// </summary>
                public string syncFlag { get; set; }

                /// <summary>
                /// 目标区域/道口 - 物理位置道口编码或B2C复核台区域编码
                /// </summary>
                public string dLocation { get; set; }

                // ... UDF01-UDF10
            }

            /// <summary>
            /// 输送线任务推送响应(支持部分成功)
            /// </summary>
            public class PutConveyorTaskResponse
            {
                public PutConveyorTaskResponseData Response { get; set; }
            }

            public class PutConveyorTaskResponseData
            {
                public PutConveyorTaskReturnInfo Return { get; set; }
            }

            public class PutConveyorTaskReturnInfo : ReturnInfo
            {
                /// <summary>
                /// 部分成功时的错误详情
                /// </summary>
                public List<TaskErrorInfo> resultInfo { get; set; }
            }
        }
        public class reportWeightinfo
        {
            public static Channel<ReportWeightInfoResponse> channel = Channel.CreateUnbounded<ReportWeightInfoResponse>();

            internal static async Task<ReportWeightInfoReturnInfo> GetChinnnl()
            {
                //var response = await reportWeightinfo.channel.Reader.ReadAllAsync();// foreach (var response in reportWeightinfo.channel.Reader.ReadAllAsync())
                //{
                //    return response?.Response?.Return ?? new ReportWeightInfoReturnInfo { ReturnCode = "0001", SortingChute = "0", ReturnDesc = "返回为空。" };
                //}
                while (await reportWeightinfo.channel.Reader.WaitToReadAsync(CancellationToken.None))
                {
                    while (reportWeightinfo.channel.Reader.TryRead(out var response))
                    {
                        return response?.Response?.Return ?? new ReportWeightInfoReturnInfo { returnCode = "0001", sortingChute = "0", returnDesc = "返回为空。" };
                    }
                }
                return new ReportWeightInfoReturnInfo { returnCode = "0001", sortingChute = "0", returnDesc = "返回为空。" };
            }

            /// <summary>
            /// 上报称重信息请求
            /// </summary>
            public class ReportWeightInfoRequest
            {
                public ReportWeightInfoData data { get; set; }
            }

            public class ReportWeightInfoData
            {
                public ReportWeightInfoHeader header { get; set; }
            }

            public class ReportWeightInfoHeader
            {
                /// <summary>
                /// 组织编号 - 主键，默认MERCURY
                /// </summary>
                public string organizationId { get; set; } = "MERCURY";

                /// <summary>
                /// 仓库编号 - 主键，默认HN02
                /// </summary>
                public string warehouseId { get; set; } = "HN02";

                /// <summary>
                /// 面单号 - 主键
                /// </summary>
                public string deliveryNo { get; set; }

                /// <summary>
                /// 重量(kg)
                /// </summary>
                public decimal grossWeight { get; set; }

                /// <summary>
                /// 体积(立方厘米)
                /// </summary>
                public decimal cube { get; set; }

                /// <summary>
                /// 创建时间
                /// </summary>
                public string addTime { get; set; }

                /// <summary>
                /// 创建设备
                /// </summary>
                public string addWho { get; set; }

                // ... UDF字段
            }

            /// <summary>
            /// 上报称重信息响应
            /// </summary>
            public class ReportWeightInfoResponse
            {
                public ReportWeightInfoResponseData Response { get; set; }
            }

            public class ReportWeightInfoResponseData
            {
                public ReportWeightInfoReturnInfo Return { get; set; }
            }

            public class ReportWeightInfoReturnInfo : ReturnInfo
            {
                /// <summary>
                /// 分拣道口 - 输送线快速分拣道口编码
                /// </summary>
                public string sortingChute { get; set; }
            }
        }

    }
}
#endregion [自定义类-VS][20250701112200484][AutoThread]