using Hanhe.iWCS.Common;
using Hanhe.iWCS.DeviceDriver;
using Hanhe.iWCS.MData;
using Hanhe.iWCS.Model;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Builders;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using static Hanhe.iWCS.JingmenGEMTwoProtocol.ApiHelper;
using static Hanhe.iWCS.JingmenGEMTwoProtocol.MESHelper;
using static Hanhe.iWCS.JingmenGEMTwoProtocol.PLCControl;
using static Hanhe.iWCS.JingmenGEMTwoProtocol.ProtocolAnalysis;

namespace Hanhe.iWCS.JingmenGEMTwoProtocol
{
    public class ERPService
    {
        /*
         * 变更优化操作：
         * 
         * 注释内容：
         *      PLCControl.SecondWeightInCache6 方法
         * 
         * **/


        static WebApiHelper api = new WebApiHelper();

        public const string ERPSwitch01 = "1";// ERP变更流程开关
        public static HardwareAccessObject hao = HardwareAccessHelper.Instance.GetEquipmentsHAO(Constants.WMS_DEVICE_TYPE_WMS);
        public static List<string> SendERPTaskType = Settings.SendERPTaskType.Split(',').ToList();//回报任务类型
        public static List<string> LoginInfo = Settings.LoginInfo.Split(',').ToList();// ERP登录接口传输信息

        /// <summary>
        /// ERP物料下发接口
        /// </summary>
        /// <param name="itemTable"></param>
        /// <returns></returns>
        public static SimpleResult Item(ERPItemTable itemTable)
        {
            SimpleResult result = new SimpleResult { success = false };

            // 查询中间表是否存在数据，如果存在，则进行更新；如果不存在，则获取当前【物料序号】，并进行累加插入数据

            var query = Query.EQ("item_code", itemTable.item_code);
            var erpItemInfo = MongoDBSingleton.Instance.FindOne<ERPItemTable>(query, "ERPItemTable");
            if (erpItemInfo != null)
            {
                var update = Update.Set("item_name", itemTable.item_name).Set("item_spec", itemTable.item_spec)
                    .Set("item_uom", itemTable.item_uom).Set("dateTime", DateTime.Now);
                MongoDBSingleton.Instance.Update<ERPItemTable>(query, update, "ERPItemTable", MongoDB.Driver.UpdateFlags.None);
                result.success = true;
            }
            else
            {
                int itemNo = 1;
                // 获取最大序号的数据
                var maxErpItemInfoList = MongoDBSingleton.Instance.FindAll<ERPItemTable>("ERPItemTable");
                if (maxErpItemInfoList.Count > 0)
                {
                    var maxErpItemInfo = maxErpItemInfoList.OrderByDescending(it => it.item_no).First();
                    if (maxErpItemInfo != null) itemNo = maxErpItemInfo.item_no + 1;
                }
                MongoDBSingleton.Instance.Insert<ERPItemTable>(new ERPItemTable
                {
                    item_no = itemNo,
                    item_code = itemTable.item_code,
                    item_name = itemTable.item_name,
                    item_spec = itemTable.item_spec,
                    item_uom = itemTable.item_uom,
                    dateTime = DateTime.Now
                }, "ERPItemTable");

                
                result.success = true;
            }
            return result;
        }

        /// <summary>
        /// ERP员工信息下发接口
        /// </summary>
        /// <param name="itemTable"></param>
        /// <returns></returns>
        public static SimpleResult Employee(ERPEmployeeTable itemTable)
        {
            SimpleResult result = new SimpleResult { success = false };

            // 查询中间表是否存在数据，如果存在，则进行更新；如果不存在，则获取当前【物料序号】，并进行累加插入数据
            //var query = Query.EQ("employee_id", itemTable.employee_id);
            //var erpItemInfo = MongoDBSingleton.Instance.FindOne<ERPEmployeeTable>(query, "ERPEmployeeTable");
            //if (erpItemInfo != null)
            //{
            //    var update = Update.Set("employee_name", itemTable.employee_name).Set("dateTime", DateTime.Now);
            //    MongoDBSingleton.Instance.Update<ERPEmployeeTable>(query, update, "ERPEmployeeTable", MongoDB.Driver.UpdateFlags.None);
            //    result.success = true;
            //}
            //else
            //{
            //    int itemNo = 1;
            //    // 获取最大序号的数据
            //    var maxErpItemInfoList = MongoDBSingleton.Instance.FindAll<ERPEmployeeTable>("ERPEmployeeTable");
            //    if (maxErpItemInfoList.Count > 0)
            //    {
            //        var maxErpItemInfo = maxErpItemInfoList.OrderByDescending(it => it.item_no).First();
            //        if (maxErpItemInfo != null) itemNo = maxErpItemInfo.item_no + 1;
            //    }
            //    MongoDBSingleton.Instance.Insert<ERPEmployeeTable>(new ERPEmployeeTable
            //    {
            //        item_no = itemNo,
            //        employee_id = itemTable.employee_id,
            //        employee_name = itemTable.employee_name,
            //        dateTime = DateTime.Now
            //    }, "ERPEmployeeTable");
            //
            //    
            //
            //    result.success = true;
            //}
            return result;
        }

        /// <summary>
        /// ERP物料中间表
        /// </summary>
        public class ERPItemTable
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 物料序号(唯一)
            /// </summary>
            public int item_no { get; set; }
            /// <summary>
            /// 物料编码(唯一)
            /// </summary>
            public string item_code { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string item_name { get; set; }
            /// <summary>
            /// 规格型号
            /// </summary>
            public string item_spec { get; set; }
            /// <summary>
            /// 单位
            /// </summary>
            public string item_uom { get; set; }
            /// <summary>
            /// 操作时间
            /// </summary>
            public DateTime dateTime { get; set; }
        }

        /// <summary>
        /// ERP员工信息中间表
        /// </summary>
        public class ERPEmployeeTable
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 物料序号(唯一)
            /// </summary>
            public int item_no { get; set; }
            /// <summary>
            /// 物料编码(唯一)
            /// </summary>
            public string item_code { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string item_name { get; set; }
            /// <summary>
            /// 员工工号
            /// </summary>
            public string employee_id { get; set; }
            /// <summary>
            /// 操作时间
            /// </summary>
            public DateTime dateTime { get; set; }
        }

        public static void SendERPTaskInfo(TN_I_TASK_MST mst)
        {
            CMMLog.Info($"SendERPTaskInfo 插入数据 开始，任务号：{mst.CN_S_SOURCE_NO}");
            if (mst.CN_S_BUSS_TYPE.Contains("电钴"))
            {
                var sendERPTaskInfo = MongoDBSingleton.Instance.FindOne<SendErpTaskInfoTableDG>(Query.EQ("taskNo", mst.CN_S_SOURCE_NO), "SendErpTaskInfoTableDG");
                if (sendERPTaskInfo != null)
                {
                    CMMLog.Info($"SendERPTaskInfo 插入数据，任务号：{mst.CN_S_SOURCE_NO}");
                    MongoDBSingleton.Instance.Update<SendErpTaskInfoTableDG>(Query.EQ("taskNo", mst.CN_S_SOURCE_NO), Update.Set("isFinish", "Y"), "SendErpTaskInfoTableDG", UpdateFlags.None);
                }
                else CMMLog.Error($"SendERPTaskInfo Error:当前任务号数据存在，不允许插入 SendErpTaskInfoTableDG 记录表。任务号：{mst.CN_S_SOURCE_NO}");
            }
            else
            {
                var sendERPTaskInfo = MongoDBSingleton.Instance.FindOne<SendErpTaskInfoTable>(Query.EQ("taskNo", mst.CN_S_SOURCE_NO), "SendErpTaskInfoTable");
                if (sendERPTaskInfo != null)
                {
                    CMMLog.Info($"SendERPTaskInfo 插入数据，任务号：{mst.CN_S_SOURCE_NO}");
                    MongoDBSingleton.Instance.Update<SendErpTaskInfoTable>(Query.EQ("taskNo", mst.CN_S_SOURCE_NO), Update.Set("isFinish", "Y"), "SendErpTaskInfoTable", UpdateFlags.None);
                }
                else CMMLog.Error($"SendERPTaskInfo Error:当前任务号数据存在，不允许插入 SendErpTaskInfoTable 记录表。任务号：{mst.CN_S_SOURCE_NO}");
            }
        }

        public class SendErpTaskInfoTable
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 任务号
            /// </summary>
            public string taskNo { get; set; } = "";
            /// <summary>
            /// 点位
            /// </summary>
            public string Bit { get; set; }
            /// <summary>
            /// 包装机号
            /// </summary>
            public string packingMachineNumber { get; set; }
            /// <summary>
            /// 袋号1
            /// </summary>
            public string bagNumber1 { get; set; }
            /// <summary>
            /// 袋号2
            /// </summary>
            public string bagNumber2 { get; set; }
            /// <summary>
            /// 袋号3
            /// </summary>
            public string bagNumber3 { get; set; }
            /// <summary>
            /// 袋号4
            /// </summary>
            public string bagNumber4 { get; set; }
            /// <summary>
            /// 物料编码(唯一)
            /// </summary>
            public string materiCode { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string materiName { get; set; }
            /// <summary>
            /// 物料规格
            /// </summary>
            public string materialSpec { get; set; }
            /// <summary>
            /// 总总量
            /// </summary>
            public int totalWeight { get; set; }
            /// <summary>
            /// 批次号
            /// </summary>
            public string lotCode { get; set; }
            /// <summary>
            /// 时间戳-对应任务数据 CN_S_BATCH_NO 字段值
            /// </summary>
            public string timeStamp { get; set; }
            /// <summary>
            /// 生产日期 
            /// </summary>
            public DateTime productTime { get; set; }
            /// <summary>
            /// 失效日期
            /// </summary>
            public DateTime invalidationTime { get; set; }
            /// <summary>
            /// 是否完成
            /// </summary>
            public string isFinish { get; set; } = "N";
            public DateTime dateTime { get; set; }
            //变更注释
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string orderCode { get; set; }
            /// <summary>
            /// 需求总重量
            /// </summary>
            public int totalNeedWeight { get; set; }
            /// <summary>
            /// 叠包后总重量（净重）
            /// </summary>
            public int netWeight { get; set; }
            /// <summary>
            /// 分录id
            /// </summary>
            public int FEntryID { get; set; }
            /// <summary>
            /// 反馈mes  1- 无需反馈，0-未反馈
            /// </summary>
            public string mesSucess { get; set; }
        }

        public class SendErpTaskInfoTableBak
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 任务号
            /// </summary>
            public string taskNo { get; set; } = "";
            /// <summary>
            /// 点位
            /// </summary>
            public string Bit { get; set; }
            /// <summary>
            /// 包装机号
            /// </summary>
            public string packingMachineNumber { get; set; }
            /// <summary>
            /// 物料编码(唯一)
            /// </summary>
            public string materiCode { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string materiName { get; set; }
            /// <summary>
            /// 物料规格
            /// </summary>
            public string materialSpec { get; set; }
            /// <summary>
            /// 总总量
            /// </summary>
            public int totalWeight { get; set; }
            /// <summary>
            /// 批次号
            /// </summary>
            public string lotCode { get; set; }
            /// <summary>
            /// 时间戳-对应任务数据 CN_S_BATCH_NO 字段值
            /// </summary>
            public string timeStamp { get; set; }
            /// <summary>
            /// 生产日期 
            /// </summary>
            public DateTime productTime { get; set; }
            /// <summary>
            /// 失效日期
            /// </summary>
            public DateTime invalidationTime { get; set; }
            /// <summary>
            /// 是否完成
            /// </summary>
            public string isFinish { get; set; } = "N";
            public DateTime dateTime { get; set; }
            //变更注释
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string orderCode { get; set; }
            /// <summary>
            /// 需求总重量
            /// </summary>
            public int totalNeedWeight { get; set; }
            /// <summary>
            /// 叠包后总重量（净重）
            /// </summary>
            public int netWeight { get; set; }
            /// <summary>
            /// 分录id
            /// </summary>
            public int FEntryID { get; set; }
            /// <summary>
            /// 是否上报 1-需要上报，0-不需要上报
            /// </summary>
            public string needReport { get; set; } = "0";
        }

        public class SendErpTaskInfoTableDG
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 任务号
            /// </summary>
            public string taskNo { get; set; } = "";
            /// <summary>
            /// 点位
            /// </summary>
            public string Bit { get; set; }
            /// <summary>
            /// 包装机号
            /// </summary>
            public string packingMachineNumber { get; set; }
            /// <summary>
            /// 袋号1
            /// </summary>
            public string bagNumber1 { get; set; }
            /// <summary>
            /// 袋号2
            /// </summary>
            public string bagNumber2 { get; set; }
            /// <summary>
            /// 袋号3
            /// </summary>
            public string bagNumber3 { get; set; }
            /// <summary>
            /// 袋号4
            /// </summary>
            public string bagNumber4 { get; set; }
            /// <summary>
            /// 物料编码(唯一)
            /// </summary>
            public string materiCode { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string materiName { get; set; }
            /// <summary>
            /// 物料规格
            /// </summary>
            public string materialSpec { get; set; }
            /// <summary>
            /// 总总量
            /// </summary>
            public int totalWeight { get; set; }
            /// <summary>
            /// 批次号
            /// </summary>
            public string lotCode { get; set; }
            /// <summary>
            /// 时间戳-对应任务数据 CN_S_BATCH_NO 字段值
            /// </summary>
            public string timeStamp { get; set; }
            /// <summary>
            /// 生产日期 
            /// </summary>
            public DateTime productTime { get; set; }
            /// <summary>
            /// 失效日期
            /// </summary>
            public DateTime invalidationTime { get; set; }
            /// <summary>
            /// 是否完成
            /// </summary>
            public string isFinish { get; set; } = "N";
            public DateTime dateTime { get; set; }
            //变更注释
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string orderCode { get; set; }
            /// <summary>
            /// 需求总重量
            /// </summary>
            public int totalNeedWeight { get; set; }
            /// <summary>
            /// 叠包后总重量（净重）
            /// </summary>
            public int netWeight { get; set; }
            /// <summary>
            /// 分录id
            /// </summary>
            public int FEntryID { get; set; }
            /// <summary>
            /// 反馈mes  1- 无需反馈，0-未反馈
            /// </summary>
            public string mesSucess { get; set; }
        }
        public class SendMESTaskInfoTable
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 任务号
            /// </summary>
            public string taskNo { get; set; } = "";
            /// <summary>
            /// 点位
            /// </summary>
            public string Bit { get; set; }
            /// <summary>
            /// 包装机号
            /// </summary>
            public string packingMachineNumber { get; set; }
            /// <summary>
            /// 袋号1
            /// </summary>
            public string bagNumber1 { get; set; }
            /// <summary>
            /// 袋号2
            /// </summary>
            public string bagNumber2 { get; set; }
            /// <summary>
            /// 袋号3
            /// </summary>
            public string bagNumber3 { get; set; }
            /// <summary>
            /// 袋号4
            /// </summary>
            public string bagNumber4 { get; set; }
            /// <summary>
            /// 物料编码(唯一)
            /// </summary>
            public string materiCode { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string materiName { get; set; }
            /// <summary>
            /// 物料规格
            /// </summary>
            public string materialSpec { get; set; }
            /// <summary>
            /// 总总量
            /// </summary>
            public int totalWeight { get; set; }
            /// <summary>
            /// 批次号
            /// </summary>
            public string lotCode { get; set; }
            /// <summary>
            /// 时间戳-对应任务数据 CN_S_BATCH_NO 字段值
            /// </summary>
            public string timeStamp { get; set; }
            /// <summary>
            /// 生产日期 
            /// </summary>
            public DateTime productTime { get; set; }
            /// <summary>
            /// 失效日期
            /// </summary>
            public DateTime invalidationTime { get; set; }
            /// <summary>
            /// 是否完成
            /// </summary>
            public string isFinish { get; set; } = "N";
            public DateTime dateTime { get; set; }
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string orderCode { get; set; }
            /// <summary>
            /// 需求总重量
            /// </summary>
            public int totalNeedWeight { get; set; }
            /// <summary>
            /// 叠包后总重量（净重）
            /// </summary>
            public int netWeight { get; set; }
            /// <summary>
            /// 分录id
            /// </summary>
            public int FEntryID { get; set; }
        }

        /// <summary>
        /// 入库任务完成回报ERP信息
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static void SendERPTaskCompleteFunc()
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                //var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTable>(Query.And(Query.EQ("isFinish", "Y"),Query.EQ("mesSucess","0")), "SendErpTaskInfoTable");
                var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTable>(Query.EQ("isFinish", "Y"), "SendErpTaskInfoTable");
                if (sendERPTaskInfoList.Count > 0)
                {
                    var timeInfo = sendERPTaskInfoList.OrderBy(a => a.dateTime).First();
                    CMMLog.Info($"SendERPTaskCompleteFunc:{sendERPTaskInfoList.Count}");
                    CMMLog.Info($"SendERPTaskCompleteFunc:{timeInfo.dateTime.AddHours(1) < DateTime.Now}");
                    if (sendERPTaskInfoList.Count == 5 || timeInfo.dateTime.AddHours(1) < DateTime.Now)
                    {
                        // 先根据任务批次号字段获取时间戳中间表-TimeCuoInfoCom 数据，并进行后续调用，处理成功删除时间戳中间表-TimeCuoInfoCom 数据

                        #region 计算单据编号
                        string FBillNO = "";
                        int num = 0;
                        string S_NUM = "";
                        string time = DateTime.Now.ToString("yyMMdd");
                        CMMLog.Info($"SendERPTaskCompleteFunc time：{time}");
                        var midInfo = db.Queryable<ADDMid>().Where(b => b.time == time).First();
                        if (midInfo != null)
                        {
                            midInfo.num = midInfo.num + 1;
                            num = midInfo.num;
                            db.Updateable(midInfo).UpdateColumns(b => new { b.num }).ExecuteCommand();
                        }
                        else
                        {
                            num = 1;
                            midInfo = new ADDMid
                            {
                                time = DateTime.Now.ToString("yyMMdd"),
                                num = 1
                            };
                            db.Insertable(midInfo).ExecuteCommand();
                        }

                        CMMLog.Info($"SendERPTaskCompleteFunc num: {num}");
                        for (int i = num.ToString().Length + 1; i <= 4; i++)
                        {
                            S_NUM = S_NUM + "0";
                        }

                        FBillNO = "ARKD" + DateTime.Now.ToString("yyMMdd") + S_NUM + num.ToString();
                        CMMLog.Info($"SendERPTaskCompleteFunc: {FBillNO}");
                        #endregion

                        int n = 0; //行号
                        sendERPTaskInfoList.ForEach(a =>
                        {
                            n = n + 1;
                            CMMLog.Info($"SendERPTaskCompleteFunc:INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','BM000161','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}',{sendERPTaskInfoList.Count},'0')");
                            string sql = $"INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','BM000161','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}',{sendERPTaskInfoList.Count},'0')";
                            new SqlHelper<object>().ExecuteSql(sql, false);

                            #region 反馈信息给mes 对接文档 https://365.kdocs.cn/l/cltzoEaznLco
                            //bool result = sendMes(JsonConvert.SerializeObject(a));
                            //
                            //if (!result)
                            //{
                            //    //将数据存入中间表，重新发送
                            //    MongoDBSingleton.Instance.Insert<SendMESTaskInfoTable>(new SendMESTaskInfoTable
                            //    {
                            //        taskNo = a.taskNo,
                            //        Bit = a.Bit,
                            //        materiCode = a.materiCode,
                            //        totalWeight = a.totalWeight,
                            //        lotCode = a.lotCode,
                            //        timeStamp = a.timeStamp,
                            //        productTime = a.productTime,
                            //        invalidationTime = a.invalidationTime,
                            //        isFinish = a.isFinish,
                            //        dateTime = a.dateTime,
                            //        orderCode = a.orderCode,
                            //    });
                            //}
                            #endregion

                            //插入成功 清除中间表
                            MongoDBSingleton.Instance.Remove<SendErpTaskInfoTable>(Query.EQ("_id", a._id), "SendErpTaskInfoTable", RemoveFlags.None);
                            MongoDBSingleton.Instance.Remove<TimeCuoInfoCom>(Query.EQ("timeStamp", int.Parse(a.timeStamp)), "TimeCuoInfoCom", RemoveFlags.None);


                        });
                    }
                }
            }
            catch(Exception ex)
            {
                CMMLog.Info("SendERPTaskCompleteFunc err:"+ex.Message);
            }
            
        }

        /// <summary>
        /// 入库任务完成回报ERP信息
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static void SendERPTaskCompleteFuncTwo()
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTable>(Query.And(Query.EQ("isFinish", "Y"),Query.EQ("mesSucess","0")), "SendErpTaskInfoTable");
                //var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTable>(Query.EQ("isFinish", "Y"), "SendErpTaskInfoTable");
                if (sendERPTaskInfoList.Count > 0)
                {
                    var timeInfo = sendERPTaskInfoList.OrderBy(a => a.dateTime).First();
                    CMMLog.Info($"SendERPTaskCompleteFunc:{sendERPTaskInfoList.Count}");
                    CMMLog.Info($"SendERPTaskCompleteFunc:{timeInfo.dateTime.AddHours(1) < DateTime.Now}");
                    if (sendERPTaskInfoList.Count == 5 || timeInfo.dateTime.AddHours(1) < DateTime.Now)
                    {
                        // 先根据任务批次号字段获取时间戳中间表-TimeCuoInfoCom 数据，并进行后续调用，处理成功删除时间戳中间表-TimeCuoInfoCom 数据
                        int count = sendERPTaskInfoList.Where(a => string.IsNullOrEmpty(a.orderCode) || a.orderCode.Length < 2 || a.orderCode.Substring(0, 2) != "MO").ToList().Count();
                        #region 计算单据编号
                        string FBillNO = "";
                        int num = 0;
                        string S_NUM = "";
                        string time = DateTime.Now.ToString("yyMMdd");
                        CMMLog.Info($"SendERPTaskCompleteFunc time：{time}");
                        var midInfo = db.Queryable<ADDMid>().Where(b => b.time == time).First();
                        if (midInfo != null)
                        {
                            midInfo.num = midInfo.num + 1;
                            num = midInfo.num;
                            db.Updateable(midInfo).UpdateColumns(b => new { b.num }).ExecuteCommand();
                        }
                        else
                        {
                            num = 1;
                            midInfo = new ADDMid
                            {
                                time = DateTime.Now.ToString("yyMMdd"),
                                num = 1
                            };
                            db.Insertable(midInfo).ExecuteCommand();
                        }

                        CMMLog.Info($"SendERPTaskCompleteFunc num: {num}");
                        for (int i = num.ToString().Length + 1; i <= 4; i++)
                        {
                            S_NUM = S_NUM + "0";
                        }

                        FBillNO = "ARKD" + DateTime.Now.ToString("yyMMdd") + S_NUM + num.ToString();
                        CMMLog.Info($"SendERPTaskCompleteFunc: {FBillNO}");
                        #endregion

                        int n = 0; //行号
                        int m = 0;
                        sendERPTaskInfoList.ForEach(a =>
                        {
                            if(!string.IsNullOrEmpty(a.orderCode) && a.orderCode.Length >= 2 && a.orderCode.Substring(0,2) == "MO")
                            {
                                m = m + 1;
                                if(m > 1)
                                {
                                    //2025-07-14 插入新表的单据编号，一条一个单据编号
                                    #region 计算单据编号
                                    S_NUM = "";
                                    midInfo = db.Queryable<ADDMid>().Where(b => b.time == time).First();
                                    if (midInfo != null)
                                    {
                                        midInfo.num = midInfo.num + 1;
                                        num = midInfo.num;
                                        db.Updateable(midInfo).UpdateColumns(b => new { b.num }).ExecuteCommand();
                                    }

                                    CMMLog.Info($"SendERPTaskCompleteFunc num: {num}");
                                    for (int i = num.ToString().Length + 1; i <= 4; i++)
                                    {
                                        S_NUM = S_NUM + "0";
                                    }

                                    FBillNO = "ARKD" + DateTime.Now.ToString("yyMMdd") + S_NUM + num.ToString();
                                    CMMLog.Info($"SendERPTaskCompleteFunc: {FBillNO}");
                                    #endregion
                                }
                                CMMLog.Info($"SendERPTaskCompleteFunc:INSERT INTO T_JY_PRDINSTOCKOP (FBillNO,FSourceBillNo,FEntryID,FSEQ,FQTY,FStockNumber,FLot,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','{a.orderCode}','{a.FEntryID}','{1}','{a.totalNeedWeight}','CK020','{a.lotCode}','{a.productTime}','{a.invalidationTime}','{a.taskNo}','{1}','0')");
                                string sql = $"INSERT INTO T_JY_PRDINSTOCKOP (FBillNO,FSourceBillNo,FEntryID,FSEQ,FQTY,FStockNumber,FLot,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','{a.orderCode}','{a.FEntryID}','{1}','{a.totalNeedWeight}','CK020','{a.lotCode}','{a.productTime}','{a.invalidationTime}','{a.taskNo}','{1}','0')";
                                if (new SqlHelper<object>().ExecuteSql(sql, false))
                                {
                                    #region 反馈信息给mes 对接文档 https://365.kdocs.cn/l/cltzoEaznLco
                                    bool result = sendMes(a, true);

                                    if (!result)
                                    {
                                        //将数据存入中间表，重新发送
                                        MongoDBSingleton.Instance.Insert<SendMESTaskInfoTable>(new SendMESTaskInfoTable
                                        {
                                            taskNo = a.taskNo,
                                            Bit = a.Bit,
                                            packingMachineNumber = a.packingMachineNumber,
                                            materiCode = a.materiCode,
                                            materiName = a.materiName,
                                            materialSpec = a.materialSpec,
                                            totalWeight = a.totalWeight,
                                            lotCode = a.lotCode,
                                            timeStamp = a.timeStamp,
                                            productTime = a.productTime,
                                            invalidationTime = a.invalidationTime,
                                            isFinish = a.isFinish,
                                            dateTime = a.dateTime,
                                            orderCode = a.orderCode,
                                            totalNeedWeight = a.totalNeedWeight,
                                            netWeight = a.netWeight,
                                            FEntryID = a.FEntryID
                                        });
                                    }
                                    #endregion
                                }
                                else
                                {
                                    //插入失败，将数据插入新表，人工手动处理，重新插入
                                    MongoDBSingleton.Instance.Insert<SendErpTaskInfoTableBak>(new SendErpTaskInfoTableBak
                                    {
                                        orderCode = a.orderCode,
                                        FEntryID = a.FEntryID,
                                        totalNeedWeight = a.totalNeedWeight,
                                        lotCode = a.lotCode,
                                        productTime = a.productTime,
                                        invalidationTime = a.invalidationTime,
                                        taskNo = a.taskNo
                                    }, "SendErpTaskInfoTableBak");
                                }
                            }
                            else
                            {
                                n = n + 1;
                                CMMLog.Info($"SendERPTaskCompleteFunc:INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','BM000161','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}','{count}','0')");
                                string sql = $"INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','BM000161','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}','{count}','0')";
                                if(new SqlHelper<object>().ExecuteSql(sql, false))
                                {
                                }
                                else
                                {
                                    //插入失败，将数据插入新表，人工手动处理，重新插入
                                    MongoDBSingleton.Instance.Insert<SendErpTaskInfoTableBak>(new SendErpTaskInfoTableBak
                                    {
                                        orderCode = a.orderCode,
                                        FEntryID = a.FEntryID,
                                        totalNeedWeight = a.totalNeedWeight,
                                        lotCode = a.lotCode,
                                        productTime = a.productTime,
                                        invalidationTime = a.invalidationTime,
                                        taskNo = a.taskNo
                                    }, "SendErpTaskInfoTableBak");
                                }
                            }
                            //插入成功 清除中间表
                            MongoDBSingleton.Instance.Remove<SendErpTaskInfoTable>(Query.EQ("_id", a._id), "SendErpTaskInfoTable", RemoveFlags.None);
                            MongoDBSingleton.Instance.Remove<TimeCuoInfoCom>(Query.EQ("timeStamp", int.Parse(a.timeStamp)), "TimeCuoInfoCom", RemoveFlags.None);
                        });
                    }
                }
            }
            catch(Exception ex)
            {
                CMMLog.Info("SendERPTaskCompleteFunc err:"+ex.Message);
            }
        }

        internal static void SendERPTaskCompleteFuncThree()
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTableBak>(Query.And(Query.EQ("needReport", "1")), "SendErpTaskInfoTableBak");
                //var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTable>(Query.EQ("isFinish", "Y"), "SendErpTaskInfoTable");
                if (sendERPTaskInfoList.Count > 0)
                {
                    CMMLog.Info($"SendERPTaskCompleteFunc:{sendERPTaskInfoList.Count}");
                    // 先根据任务批次号字段获取时间戳中间表-TimeCuoInfoCom 数据，并进行后续调用，处理成功删除时间戳中间表-TimeCuoInfoCom 数据
                    int n = 0; //行号
                    sendERPTaskInfoList.ForEach(a =>
                    {
                        n = n + 1;
                        #region 计算单据编号
                        string FBillNO = "";
                        int num = 0;
                        string S_NUM = "";
                        string time = DateTime.Now.ToString("yyMMdd");
                        CMMLog.Info($"SendERPTaskCompleteFunc time：{time}");
                        var midInfo = db.Queryable<ADDMid>().Where(b => b.time == time).First();
                        if (midInfo != null)
                        {
                            midInfo.num = midInfo.num + 1;
                            num = midInfo.num;
                            db.Updateable(midInfo).UpdateColumns(b => new { b.num }).ExecuteCommand();
                        }
                        else
                        {
                            num = 1;
                            midInfo = new ADDMid
                            {
                                time = DateTime.Now.ToString("yyMMdd"),
                                num = 1
                            };
                            db.Insertable(midInfo).ExecuteCommand();
                        }

                        CMMLog.Info($"SendERPTaskCompleteFunc num: {num}");
                        for (int i = num.ToString().Length + 1; i <= 4; i++)
                        {
                            S_NUM = S_NUM + "0";
                        }

                        FBillNO = "ARKD" + DateTime.Now.ToString("yyMMdd") + S_NUM + num.ToString();
                        CMMLog.Info($"SendERPTaskCompleteFunc: {FBillNO}");
                        #endregion

                        if (!string.IsNullOrEmpty(a.orderCode) && a.orderCode.Length >= 2 && a.orderCode.Substring(0, 2) == "MO")
                        {
                            CMMLog.Info($"SendERPTaskCompleteFunc:INSERT INTO T_JY_PRDINSTOCKOP (FBillNO,FSourceBillNo,FEntryID,FSEQ,FQTY,FStockNumber,FLot,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','{a.orderCode}','{a.FEntryID}','1','{a.totalNeedWeight}','CK020','{a.lotCode}','{a.productTime}','{a.invalidationTime}','{a.taskNo}','1','0')");
                            string sql = $"INSERT INTO T_JY_PRDINSTOCKOP (FBillNO,FSourceBillNo,FEntryID,FSEQ,FQTY,FStockNumber,FLot,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','{a.orderCode}','{a.FEntryID}','1','{a.totalNeedWeight}','CK020','{a.lotCode}','{a.productTime}','{a.invalidationTime}','{a.taskNo}','1','0')";
                            if (new SqlHelper<object>().ExecuteSql(sql, false))
                            {
                                #region 反馈信息给mes 对接文档 https://365.kdocs.cn/l/cltzoEaznLco
                                bool result = sendMes(a, true);

                                if (!result)
                                {
                                    //将数据存入中间表，重新发送
                                    MongoDBSingleton.Instance.Insert<SendMESTaskInfoTable>(new SendMESTaskInfoTable
                                    {
                                        taskNo = a.taskNo,
                                        Bit = a.Bit,
                                        packingMachineNumber = a.packingMachineNumber,
                                        materiCode = a.materiCode,
                                        materiName = a.materiName,
                                        materialSpec = a.materialSpec,
                                        totalWeight = a.totalWeight,
                                        lotCode = a.lotCode,
                                        timeStamp = a.timeStamp,
                                        productTime = a.productTime,
                                        invalidationTime = a.invalidationTime,
                                        isFinish = a.isFinish,
                                        dateTime = a.dateTime,
                                        orderCode = a.orderCode,
                                        totalNeedWeight = a.totalNeedWeight,
                                        netWeight = a.netWeight,
                                        FEntryID = a.FEntryID
                                    });
                                }
                                #endregion

                                //插入成功 清除中间表
                                MongoDBSingleton.Instance.Remove<SendErpTaskInfoTableBak>(Query.EQ("_id", a._id), "SendErpTaskInfoTableBak", RemoveFlags.None);
                            }
                        }
                        else
                        {
                            CMMLog.Info($"SendERPTaskCompleteFunc:INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','BM000161','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}',{sendERPTaskInfoList.Count},'0')");
                            string sql = $"INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','BM000161','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}',{sendERPTaskInfoList.Count},'0')";
                            if (new SqlHelper<object>().ExecuteSql(sql, false))
                            {
                                //插入成功 清除中间表
                                MongoDBSingleton.Instance.Remove<SendErpTaskInfoTableBak>(Query.EQ("_id", a._id), "SendErpTaskInfoTableBak", RemoveFlags.None);
                            }
                        }
                    });
                }
            }
            catch (Exception ex)
            {
                CMMLog.Info("SendERPTaskCompleteFunc err:" + ex.Message);
            }
        }

        private static bool sendMes(object jsonData,bool action)
        {
            bool result = true;

            //var a = JsonConvert.DeserializeObject<SendMESTaskInfoTable>(jsonData);
            try
            {
                MESInModel model = new MESInModel();
                model.apiCode = "MES010";
                model.jsonData = new List<JsonData>();

                if (action)
                {
                    SendErpTaskInfoTable a = (SendErpTaskInfoTable)jsonData;
                    int DBNum = a.bagNumber4 != "000" ? 4 : a.bagNumber3 != "000" ? 3 : a.bagNumber2 != "000" ? 2 : 1;
                    model.jsonData.Add(new JsonData()
                    {
                        orderCode = a.orderCode,
                        materialCode = a.materiCode,
                        materialName = a.materiName,
                        materialSpec = a.materialSpec,
                        batchCode = a.lotCode,
                        lineCode = a.packingMachineNumber,
                        needNum = a.totalNeedWeight.ToString(),
                        realityNum = a.netWeight.ToString(),
                        inDateTime = a.productTime.ToString(),
                        diebaoNum = DBNum,
                        bagCode = a.timeStamp
                    });
                }
                else
                {
                    SendMESTaskInfoTable a = (SendMESTaskInfoTable)jsonData;
                    int DBNum = a.bagNumber4 != "000" ? 4 : a.bagNumber3 != "000" ? 3 : a.bagNumber2 != "000" ? 2 : 1;
                    model.jsonData.Add(new JsonData()
                    {
                        orderCode = a.orderCode,
                        materialCode = a.materiCode,
                        materialName = a.materiName,
                        materialSpec = a.materialSpec,
                        batchCode = a.lotCode,
                        lineCode = a.packingMachineNumber,
                        needNum = a.totalNeedWeight.ToString(),
                        realityNum = a.netWeight.ToString(),
                        inDateTime = a.productTime.ToString(),
                        diebaoNum = DBNum,
                        bagCode = a.timeStamp
                    });
                }


                string msgData = JsonConvert.SerializeObject(model);

                CMMLog.Info($"MESIn:【反馈MES入库物料信息】:发送数据：{JsonConvert.SerializeObject(msgData)}");
                var url = Settings.MESUrl;
                string feedback = "";
                string msg = "";
                try
                {
                    feedback = helper.WebPost(url, msgData).Replace(@"\", "").Trim();
                    CMMLog.Info($"MESIn:【反馈MES入库物料信息】:接收数据：" + feedback);
                    if (!string.IsNullOrEmpty(feedback))
                    {
                        var mesResponse = JsonConvert.DeserializeObject<MESResponseModel>(feedback);
                        if (mesResponse.isSuccess == true)
                        {
                            msg = $"MESIn:【反馈MES入库物料信息】成功！返回结果=" + mesResponse.isSuccess + ";调用WebUrl=" + url + ";输入参数=" + msgData;
                        }
                        else
                        {
                            string errMsg = mesResponse.code + "-" + mesResponse.msg;
                            msg = $"MESIn:【反馈MES入库物料信息】失败！错误原因=" + errMsg + ";调用WebUrl=" + url + ";输入参数=" + msgData;
                            result = false;
                        }
                    }
                    else
                    {
                        string errMsg = "参数反馈空值";
                        msg = $"MESIn:【反馈MES入库物料信息】失败！错误原因=" + errMsg + ";调用WebUrl=" + url + ";输入参数=" + msgData;
                        result = false;
                    }
                }
                catch (Exception e)
                {
                    CMMLog.Error(string.Format("【调用wms获取入库货位失败】异常{0}", e.Message), e);
                    msg = $"MESIn:【反馈MES入库物料信息】失败！解析返回值出错=" + feedback + ";调用WebUrl=" + url + ";输入参数=" + msgData;
                    result = false;
                }
                CMMLog.Info(msg);
                return result;
            }
            catch(Exception ex)
            {
                CMMLog.Info($"sendMes err:" + ex.Message);
                return false;
            }
            
        }

        public class MESInModel
        {
            /// <summary>
            /// 接口编码
            /// </summary>
            public string apiCode { get; set; }
            public List<JsonData> jsonData { get; set; }
        }
        public class JsonData
        {
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string orderCode { get; set; }
            /// <summary>
            /// 物料编码
            /// </summary>
            public string materialCode { get; set; }
            /// <summary>
            /// 物料名称
            /// </summary>
            public string materialName { get; set; }
            /// <summary>
            /// 物料规格
            /// </summary>
            public string materialSpec { get; set; }
            /// <summary>
            /// 批号
            /// </summary>
            public string batchCode { get; set; }
            /// <summary>
            /// 产线编码
            /// </summary>
            public string lineCode { get; set; }
            /// <summary>
            /// 需求重量
            /// </summary>
            public string needNum { get; set; }
            /// <summary>
            /// 实际净重
            /// </summary>
            public string realityNum { get; set; }
            /// <summary>
            /// 入库时间
            /// </summary>
            public string inDateTime { get; set; }
            /// <summary>
            /// 叠包数
            /// </summary>
            public int diebaoNum { get; set; }
            /// <summary>
            /// 唯一标识 (时间戳)
            /// </summary>
            public string bagCode { get; set; }
        }
        public class MESResponseModel
        {
            public string code { get; set; }
            public string msg { get; set; }
            public string data { get; set; }
            public string selectItems { get; set; }
            public string apiId { get; set; }
            public string apiName { get; set; }
            public bool isError { get; set; }
            public bool isSuccess { get; set; }
        }

        public class ADDMid
        {
            [SugarColumn(IsPrimaryKey = true)]
            public string time { get; set; }
            public int num { get; set; }
        }

        /// <summary>
        /// ERP交互方法:打包下线任务创建前 调用 批号主档 接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static bool ERPApiFunc(string timeStamp)
        {
            bool result = false;
            try
            {
                var model = MongoDBSingleton.Instance.FindOne<TimeCuoInfoCom>(Query.EQ("timeStamp", int.Parse(timeStamp)), "TimeCuoInfoCom");
                if (model != null)
                {
                    string userToken = ERPGetLogin();
                    if (!string.IsNullOrEmpty(userToken))
                    {
                        // 打包下线任务创建前 调用 批号主档 接口
                        result = ERPBatchInfo(userToken, model);
                    }
                    else CMMLog.Error($"ERPApiFunc Error:未获取到userToken.");
                }
                else CMMLog.Error($"ERPApiFunc Error:当前任务未获取到对应的时间戳数据。时间戳：{timeStamp}，时间戳表：TimeCuoInfoCom");
            }
            catch(Exception ex)
            {
                CMMLog.Error($"ERPApiFun Error:{ex.Message}");
            }
            

            
            return result;
        }

        /// <summary>
        /// ERP交互方法:任务完成调用 条码主档 接口
        /// </summary>
        /// <param name="timeStamp"></param>
        /// <returns></returns>
        public static bool ERPApiFuncTwo(string timeStamp)
        {
            bool result = false;
            try
            {
                var model = MongoDBSingleton.Instance.FindOne<TimeCuoInfoCom>(Query.EQ("timeStamp", int.Parse(timeStamp)), "TimeCuoInfoCom");
                if (model != null)
                {
                    string userToken = ERPGetLogin();
                    if (!string.IsNullOrEmpty(userToken))
                    {
                        // 任务完成调用 条码主档 接口
                        result = ERPBarCodeInfo(userToken, model);
                    }
                    else CMMLog.Error($"ERPApiFuncTwo Error:未获取到userToken.");
                }
                else CMMLog.Error($"ERPApiFuncTwo Error:当前任务未获取到对应的时间戳数据。时间戳：{timeStamp}，时间戳表：TimeCuoInfoCom");
            }
            catch (Exception ex)
            {
                CMMLog.Error($"ERPApiFuncTwo Error:{ex.Message}");
            }

            return result;
        }

        public static string CooKie = "";
        /// <summary>
        /// ERP登录接口
        /// </summary>
        public static string ERPGetLogin()
        {
            // 获取配置文件数据
            string userToken = "";
            try
            {
                string res = JsonConvert.SerializeObject(new
                {
                    parameters = new ArrayList { LoginInfo[0], LoginInfo[1], LoginInfo[2], int.Parse(LoginInfo[3]) }
                });
                string feedback = "";
                string url = Settings.GetThirdUrlList().Where(a => a.UrlNo == "1" && a.enable == 1).FirstOrDefault().Url;
                CMMLog.Info($"ERPGetLogin Res:{res},url:{url}");
                feedback = api.WebPost(url, res,"","GetCooKie");
                CMMLog.Info($"ERPGetLogin Req:{feedback}");
                if (!string.IsNullOrEmpty(feedback))
                {
                    var response = JsonConvert.DeserializeObject<ERPGetLoginResModel>(feedback);
                    if (response.IsSuccessByAPI && !string.IsNullOrEmpty(CooKie)) userToken = CooKie;
                    else CMMLog.Info($"ERPGetLogin:调用接口失败，获取Cookie失败。");
                }
            }
            catch (Exception ex)
            {
                CMMLog.Error($"WMSPost WmsInTask Error:{ex.Message}");
            }
            CMMLog.Info($"ERPGetLogin userToken:{userToken}");
            return userToken;
        }
        public class ERPGetLoginResModel
        {
            public string Message { get; set; }
            public string MessageCode { get; set; }
            public int LoginResultType { get; set; }
            public ERPGetLoginResContextModel Context { get; set; }
            public class ERPGetLoginResContextModel
            {
                public string UserToken { get; set; }
            }

            /// <summary>
            /// 接口调用状态 成功-true 失败-false
            /// </summary>
            public bool IsSuccessByAPI { get; set; }
        }

        /// <summary>
        /// 发送ERP批号主档数据
        /// </summary>
        /// <returns></returns>
        public static bool ERPBatchInfo(string userToken, TimeCuoInfoCom model)
        {
            bool result = false;

            try
            {
                ERPBatchInfoModel sendInfo = new ERPBatchInfoModel();
                sendInfo.Model.FCreateOrgId.FNumber = model.createOrganization;
                sendInfo.Model.FMaterialID.FNumber = model.materialCode;
                sendInfo.Model.FNumber = model.batchNumber;
                sendInfo.Model.FProduceDeptID.FNumber = model.workshopCode;
                sendInfo.Model.FInStockDate = model.BusinessDate;

                string res = JsonConvert.SerializeObject(new
                {
                    parameters = new ArrayList { "BD_BatchMainFile", JsonConvert.SerializeObject(sendInfo) }
                });
                string feedback = "";
                string url = Settings.GetThirdUrlList().Where(a => a.UrlNo == "3" && a.enable == 1).FirstOrDefault().Url;
                CMMLog.Info($"ERPBatchInfo Res:{res},Cookie:{userToken},url:{url}");
                feedback = api.WebPost(url, res, userToken);
                CMMLog.Info($"ERPBatchInfo Req:{feedback}");
                if (!string.IsNullOrEmpty(feedback))
                {
                    var response = JsonConvert.DeserializeObject<ERPResModel>(feedback);
                    result = response.Result.ResponseStatus.IsSuccess;
                }
            }
            catch (Exception ex)
            {
                CMMLog.Error($"ERPBatchInfo WmsInTask Error:{ex.Message}");
            }


            return result;
        }
        public class ERPBatchInfoModel
        {
            public string Creator { get; set; } = "";
            public Array NeedUpDateFields { get; set; } = new Array[0];
            public Array NeedReturnFields { get; set; } = new Array[0];
            public string IsDeleteEntry { get; set; } = "true";
            public string SubSystemId { get; set; } = "";
            public string IsVerifyBaseDataField { get; set; } = "false";
            public string IsEntryBatchFill { get; set; } = "true";
            public string ValidateFlag { get; set; } = "true";
            public string NumberSearch { get; set; } = "true";
            public string InterationFlags { get; set; } = "";
            public string IsAutoSubmitAndAudit { get; set; } = "false";
            public ModelModel Model { get; set; } = new ModelModel();
            public class ModelModel
            {
                public int FLOTID { get; set; } = 0;

                public FCreateOrgIdModel FCreateOrgId { get; set; } = new FCreateOrgIdModel();
                public class FCreateOrgIdModel
                {
                    /// <summary>
                        /// 创建组织
                        /// </summary>
                    public string FNumber { get; set; }
                }
                public FMaterialIDModel FMaterialID { get; set; } = new FMaterialIDModel();
                public class FMaterialIDModel
                {
                    /// <summary>
                        /// 物料编码
                        /// </summary>
                    public string FNumber { get; set; }
                }
                /// <summary>
                    /// 批号
                    /// </summary>
                public string FNumber { get; set; }
                public FProduceDeptIDModel FProduceDeptID { get; set; } = new FProduceDeptIDModel();
                public class FProduceDeptIDModel
                {
                    /// <summary>
                        /// 车间编码
                        /// </summary>
                    public string FNumber { get; set; }
                }
                /// <summary>
                    /// 业务日期
                    /// </summary>
                public string FInStockDate { get; set; }
            }
        }

        /// <summary>
        /// 发送ERP条码主档数据
        /// </summary>
        /// <returns></returns>
        public static bool ERPBarCodeInfo(string userToken, TimeCuoInfoCom model)
        {
            bool result = false;

            try
            {
                ERPBarCodeInfoModel sendInfo = new ERPBarCodeInfoModel();

                sendInfo.Model.FBarCode = model.barcode;
                sendInfo.Model.FBarCodeRule.FNumber = model.codeRules;
                sendInfo.Model.FMaterialID.FNumber = model.materialCode;
                sendInfo.Model.F_JY_CZZ.FNumber = model.employeeID1;
                sendInfo.Model.FCreateOrgId.FNumber = model.createOrganization;
                sendInfo.Model.FLot.FNumber = model.batchNumber;
                sendInfo.Model.FUnitId.FNumber = model.measurementUnit;
                sendInfo.Model.FQty = model.count;
                sendInfo.Model.FStockId.FNumber = model.WarehouseCode;
                sendInfo.Model.FDeptId.FNumber = model.workshopCode;
                sendInfo.Model.FBillDate = model.BusinessDate;

                string res = JsonConvert.SerializeObject(new
                {
                    parameters = new ArrayList { "BD_BarCodeMainFile", JsonConvert.SerializeObject(sendInfo) }
                });
                string feedback = "";
                string url = Settings.GetThirdUrlList().Where(a => a.UrlNo == "2" && a.enable == 1).FirstOrDefault().Url;
                CMMLog.Info($"ERPBarCodeInfo Res:{res},Cookie:{userToken},url:{url}");
                feedback = api.WebPost(url, res, userToken);
                CMMLog.Info($"ERPBarCodeInfo Req:{feedback}");
                if (!string.IsNullOrEmpty(feedback))
                {
                    var response = JsonConvert.DeserializeObject<ERPResModel>(feedback);
                    result = response.Result.ResponseStatus.IsSuccess;
                }
            }
            catch (Exception ex)
            {
                CMMLog.Error($"ERPBarCodeInfo Error:{ex.Message}");
            }


            return result;
        }
        public class ERPBarCodeInfoModel
        {
            public string Creator { get; set; } = "";
            public Array NeedUpDateFields { get; set; } = new Array[0];
            public Array NeedReturnFields { get; set; } = new Array[0];
            public string IsDeleteEntry { get; set; } = "true";
            public string SubSystemId { get; set; } = "";
            public string IsVerifyBaseDataField { get; set; } = "false";
            public string IsEntryBatchFill { get; set; } = "true";
            public string ValidateFlag { get; set; } = "true";
            public string NumberSearch { get; set; } = "true";
            public string InterationFlags { get; set; } = "";
            public string IsAutoSubmitAndAudit { get; set; } = "false";
            public ModelModel Model { get; set; } = new ModelModel();
            public class ModelModel
            {
                public int FID { get; set; } = 0;
                /// <summary>
                    /// 条形码
                    /// </summary>
                public string FBarCode { get; set; }
                public FBarCodeRuleModel FBarCodeRule { get; set; } = new FBarCodeRuleModel();
                public class FBarCodeRuleModel
                {
                    /// <summary>
                    /// 条码规则
                    /// </summary>
                    public string FNumber { get; set; }
                }
                public FMaterialIDModel FMaterialID { get; set; } = new FMaterialIDModel();
                public class FMaterialIDModel
                {
                    /// <summary>
                        /// 物料编码
                        /// </summary>
                    public string FNumber { get; set; }
                }
                public F_JY_CZZModel F_JY_CZZ { get; set; } = new F_JY_CZZModel();
                public class F_JY_CZZModel
                {
                    /// <summary>
                    /// 员工编号
                    /// </summary>
                    public string FNumber { get; set; }
                }
                public FCreateOrgIdModel FCreateOrgId { get; set; } = new FCreateOrgIdModel();
                public class FCreateOrgIdModel
                {
                    /// <summary>
                        /// 创建组织
                        /// </summary>
                    public string FNumber { get; set; }
                }
                public FLotModel FLot { get; set; } = new FLotModel();
                public class FLotModel
                {
                    /// <summary>
                    /// 批号
                    /// </summary>
                    public string FNumber { get; set; }
                }
                public FUnitIdModel FUnitId { get; set; } = new FUnitIdModel();
                public class FUnitIdModel
                {
                    /// <summary>
                    /// 计量单位
                    /// </summary>
                    public string FNumber { get; set; }
                }
                /// <summary>
                /// 数量
                /// </summary>
                public int FQty { get; set; }
                public FStockIdModel FStockId { get; set; } = new FStockIdModel();
                public class FStockIdModel
                {
                    /// <summary>
                    /// 仓库编码
                    /// </summary>
                    public string FNumber { get; set; }
                }
                public FDeptIdModel FDeptId { get; set; } = new FDeptIdModel();
                public class FDeptIdModel
                {
                    /// <summary>
                    /// 车间编码
                    /// </summary>
                    public string FNumber { get; set; }
                }
                /// <summary>
                /// 业务日期
                /// </summary>
                public string FBillDate { get; set; }
            }
        }

        public class ERPResModel
        {
            public ResultModel Result { get; set; }

            public class ResultModel
            {
                public ResponseStatusModel ResponseStatus { get; set; }

                public class ResponseStatusModel
                {
                    public bool IsSuccess { get; set; }
                    public int MsgCode { get; set; }
                }
            }
        }


        /// <summary>
        /// 写入包装机物料信息
        /// </summary>
        /// <param name="plcInfo"></param>
        public static void WriteItemInfo(Settings.PlcInfo plcInfo)
        {
            CMMLog.Debug($"WriteItemInfo:Start!");

            try
            {
                //读取【翻页】通道数据
                var result = OITcpHelper.RegisterReadOutPut(new OITcpHelper.RegisterReadOutPutModel
                {
                    dataNum = 1,
                    addr = plcInfo.FyReadAddr,
                    host = plcInfo.ip,
                    port = plcInfo.port
                });
                CMMLog.Debug($"WriteItemInfo:读取【翻页】通道数据为：{JsonConvert.SerializeObject(result)}!");
                if (true) // result != null && result.errCode == 0
                {
                    // 示例：读出值为1 获取1~5编号的物料数据;读出值为2 获取6~10编号的物料数据 规则 result.result[0] * 5 - 4 起始编号
                    //int startItemNo = 1;
                    int startItemNo = result.result[0] * 5 - 4;
                    CMMLog.Debug($"WriteItemInfo:翻页数据为：{startItemNo}!");
                    var reLocationTask = MongoDBSingleton.Instance.Find<ERPItemTable>(Query.And(Query.In("item_no", new List<MongoDB.Bson.BsonValue>() { startItemNo, startItemNo + 1, startItemNo + 2, startItemNo + 3, startItemNo + 4 })), "ERPItemTable").ToList();
                    int reLocationTaskNum = reLocationTask != null ? reLocationTask.Count : 0;
                    CMMLog.Debug($"WriteItemInfo:查询出ERP物料表数据数量为：{reLocationTaskNum}!备注：只有数量为5才会写入数据");
                    if (reLocationTaskNum == 5)
                    {
                        int no = 0;
                        reLocationTask.ForEach(a =>
                        {
                            int writeAddr = plcInfo.FyWriteAddr + no * 100;
                            no++;
                            // 解析物料数据并写入 有效数据通道 70,共100(产品批次号-20 产品型号-10 物料编码-20 物料名称-15 计量单位-5 剩余30无用通道)
                            int[] num = new int[100];
                            // 内存地址 0~19 协议地址 1~20  批次号 人工输入,不需要程序写入
                            for (int i = 0; i <= 19; i++) num[i] = 0;
                            // 内存地址 20~29 协议地址 21~30 产品型号
                            // HandleItemInfo(a.item_spec, 20, 29, num);
                            HandleItemInfo(a.item_spec, 20, 29, num);
                            CMMLog.Debug($"WriteItemInfo:物料信息处理-2。处理数据：{a.item_spec},处理后数据：{JsonConvert.SerializeObject(num)}");
                            // 内存地址 30~49 协议地址 31~50 物料编码
                            HandleItemInfo(a.item_code, 30, 49, num);
                            CMMLog.Debug($"WriteItemInfo:物料信息处理-2。处理数据：{a.item_code},处理后数据：{JsonConvert.SerializeObject(num)}");
                            // 内存地址 50~64 协议地址 51~65 物料名称
                            // HandleItemInfo(a.item_name, 50, 64, num);
                            HandleItemInfoChina(a.item_name, 50, 64, num);// 中文处理
                            CMMLog.Debug($"WriteItemInfo:物料信息处理-2。处理数据：{a.item_name},处理后数据：{JsonConvert.SerializeObject(num)}");
                            // 内存地址 65~69 协议地址 66~70 计量单位
                            HandleItemInfo(a.item_uom, 65, 69, num);
                            CMMLog.Debug($"WriteItemInfo:物料信息处理-2。处理数据：{a.item_uom},处理后数据：{JsonConvert.SerializeObject(num)}");
                            // 内存地址 70~79 协议地址 71~100 空余地址
                            for (int i = 70; i <= 99; i++) num[i] = 0;

                            CMMLog.Debug($"WriteItemInfo:发送物料信息。序号：{a.item_no},ip:{plcInfo.ip},port:{plcInfo.port},写入起始地址:{writeAddr},写入数据:{JsonConvert.SerializeObject(num)}");

                            var wirteall01 = OITcpHelper.RegisterWriteOutPutMulti(new OITcpHelper.RegisterWriteOutPutModelMulti
                            {
                                addr = writeAddr,
                                host = plcInfo.ip,
                                port = plcInfo.port,
                                data = num
                            });
                            int writeResult = wirteall01 != null ? wirteall01.errCode : 1;
                            CMMLog.Debug($"WriteItemInfo:发送物料信息。序号：{a.item_no},写入结果：{writeResult}。ip:{plcInfo.ip},port:{plcInfo.port},写入起始地址:{writeAddr},写入数据:{JsonConvert.SerializeObject(num)}");
                        });
                    }
                }
                else CMMLog.Debug($"WriteItemInfo:未读取【翻页】通道数据!");
            }
            catch (Exception ex)
            {
                CMMLog.Debug($"WriteItemInfo Error:{ex.Message}");
            }

            CMMLog.Debug($"WriteItemInfo:End!");
        }

        /// <summary>
        /// 写入包装机物料信息
        /// </summary>
        /// <param name="a"></param>
        internal static void WriteEmpInfo(Settings.PlcInfo plcInfo)
        {
            CMMLog.Debug($"WriteEmpInfo:Start!");
            var db = new SqlHelper<object>().GetInstance(false);

            try
            {
                //读取【翻页】通道数据
                var result = OITcpHelper.RegisterReadOutPut(new OITcpHelper.RegisterReadOutPutModel
                {
                    dataNum = 1,
                    addr = plcInfo.FyEmpReadAddr,
                    host = plcInfo.ip,
                    port = plcInfo.port
                });
                CMMLog.Debug($"WriteEmpInfo:读取【翻页】通道 ip:{plcInfo.ip},port:{plcInfo.port},addr:{plcInfo.FyEmpReadAddr}数据为：{JsonConvert.SerializeObject(result.result[0])}!");
                if (true) // result != null && result.errCode == 0
                {
                    // 示例：读出值为1 获取1~10编号的员工数据;读出值为2 获取11~20编号的员工数据 规则 result.result[0] * 10 - 9 起始编号
                    int startItemNo = result.result[0] * 10 - 9;
                    CMMLog.Debug($"WriteEmpInfo:翻页数据为：{startItemNo}!");

                    var reLocationTask = MongoDBSingleton.Instance.Find<ERPEmployeeTable>(Query.And(Query.In("item_no", new List<MongoDB.Bson.BsonValue>() { startItemNo, startItemNo + 1, startItemNo + 2, startItemNo + 3, startItemNo + 4, startItemNo + 5, startItemNo + 6, startItemNo + 7, startItemNo + 8, startItemNo + 9 })), "ERPEmployeeTable").ToList();
                    int reLocationTaskNum = reLocationTask != null ? reLocationTask.Count : 0;
                    CMMLog.Debug($"WriteEmpInfo:查询出ERP员工表数据数量为：{reLocationTaskNum}!备注：只有数量为10才会写入数据");
                    if (reLocationTaskNum == 10)
                    {
                        int no = 0;
                        reLocationTask.ForEach(a =>
                        {
                            int writeAddr = plcInfo.FyEmpWriteAddr + no * 5; //（205）
                            no++;
                            // 解析物料数据并写入 有效数据通道 70,共100(产品批次号-20 产品型号-10 物料编码-20 物料名称-15 计量单位-5 剩余30无用通道)
                            int[] num = new int[5];
                            // 内存地址 0~4 协议地址 1~5 计量单位
                            HandleEmpInfo(a.employee_id, 0, 4, num);

                            CMMLog.Debug($"WriteEmpInfo:发送员工信息。序号：{a.item_no},ip:{plcInfo.ip},port:{plcInfo.port},写入起始地址:{writeAddr},写入数据:{JsonConvert.SerializeObject(num)}");

                            var wirteall01 = OITcpHelper.RegisterWriteOutPutMulti(new OITcpHelper.RegisterWriteOutPutModelMulti
                            {
                                addr = writeAddr,
                                host = plcInfo.ip,
                                port = plcInfo.port,
                                data = num
                            });
                            int writeResult = wirteall01 != null ? wirteall01.errCode : 1;
                            CMMLog.Debug($"WriteEmpInfo:发送员工信息。序号：{a.item_no},写入结果：{writeResult}。ip:{plcInfo.ip},port:{plcInfo.port},写入起始地址:{writeAddr},写入数据:{JsonConvert.SerializeObject(num)}");
                        });
                    }
                }
                else CMMLog.Debug($"WriteEmpInfo:未读取【翻页】通道数据!");
            }
            catch (Exception ex)
            {
                CMMLog.Debug($"WriteEmpInfo Error:{ex.Message}");
            }

            CMMLog.Debug($"WriteEmpInfo:End!");
        }


        public static void HandleEmpInfo(string empInfo, int startIndex, int endIndex, int[] num)
        {
            string data = empInfo;// 要写入的处理后数据
            string dataHeader = "";// 数据头处理
            int dataCutCont = 0;// 数据截取开关
            if (empInfo.Length % 2 != 0)
            {
                data = "0" + empInfo;
                dataHeader = "" + empInfo.Substring(0, 1);
            }
            int maxLength = startIndex - 1 + (data.Length / 2);// data.Length / 2 至少为 1
            for (int i = startIndex; i <= maxLength; i++)
            {
                num[i] = int.Parse(PLCControl.AsciiToTen(data.Substring(dataCutCont, 2)));
                dataCutCont = dataCutCont + 2;
            }
            if (!string.IsNullOrEmpty(dataHeader)) num[startIndex] = int.Parse(PLCControl.AsciiToTen(dataHeader));
            for (int i = maxLength + 1; i <= endIndex; i++) num[i] = 0;//将当前处理完数据的其他无数据的通道全部置为 0
            CMMLog.Debug($"WriteEmpInfo:物料信息处理-1。处理数据：{empInfo},处理后数据：{JsonConvert.SerializeObject(num)}");
        }

        public static void HandleItemInfo(string itemInfo,int startIndex, int endIndex , int[] num)
        {
            string data = itemInfo;// 要写入的处理后数据
            string dataHeader = "";// 数据头处理
            int dataCutCont = 0;// 数据截取开关
            if (itemInfo.Length % 2 != 0)
            {
                data = "0" + itemInfo;
                dataHeader = "" + itemInfo.Substring(0, 1);
            }
            int maxLength = startIndex - 1 + (data.Length / 2);// data.Length / 2 至少为 1
            for (int i = startIndex; i <= maxLength; i++)
            {
                num[i] = int.Parse(PLCControl.AsciiToTen(data.Substring(dataCutCont, 2)));
                dataCutCont = dataCutCont + 2;
            }
            if (!string.IsNullOrEmpty(dataHeader)) num[startIndex] = int.Parse(PLCControl.AsciiToTen(dataHeader));
            for (int i = maxLength + 1; i <= endIndex; i++) num[i] = 0;//将当前处理完数据的其他无数据的通道全部置为 0
            CMMLog.Debug($"WriteItemInfo:物料信息处理-1。处理数据：{itemInfo},处理后数据：{JsonConvert.SerializeObject(num)}");
        }

        public static void HandleItemInfoChina(string itemInfo, int startIndex, int endIndex, int[] num)
        {
            string data = itemInfo;// 要写入的处理后数据
            int dataCutCont = 0;// 数据截取开关
            int maxLength = startIndex - 1 + data.Length;// data.Length / 2 至少为 1
            for (int i = startIndex; i <= maxLength; i++)
            {
                num[i] = Test.ConvertToAscii(char.Parse(data.Substring(dataCutCont, 1)));
                dataCutCont = dataCutCont + 1;
            }
            for (int i = maxLength + 1; i <= endIndex; i++) num[i] = 0;//将当前处理完数据的其他无数据的通道全部置为 0
            CMMLog.Debug($"WriteItemInfo:物料信息处理-1。处理数据：{itemInfo},处理后数据：{JsonConvert.SerializeObject(num)}");
        }

        /// <summary>
        /// 获取员工编码
        /// </summary>
        /// <returns></returns>
        public static string GetEmployeeId(int readAddr,string ip,int port)
        {
            string employeeId = "";
            var employeeIdAction = OITcpHelper.RegisterReadOutPut(new OITcpHelper.RegisterReadOutPutModel
            {
                addr = readAddr,
                host = ip,
                port = port,
                dataNum = 2
            });
            employeeId = Convert.ToInt32(PLCControl.Completion(employeeIdAction.result[0]) + PLCControl.Completion(employeeIdAction.result[1]), 2).ToString();

            return employeeId;
        }


        public static string packageCont = "1";// 包装机复称UI变更功能开关  1-开启 0-关闭

        /// <summary>
        /// 插入包装机信息表
        /// </summary>
        public static void packageInfo(string machineNo, string trayCode, string lotNo, string oneTrayWeight)
        {
            if (packageCont == "1")
            {
                try
                {
                    MongoDBSingleton.Instance.Insert<packageInfoModel>(new packageInfoModel
                    {
                        machineNo = machineNo,
                        trayCode = trayCode,
                        batchNo = lotNo,
                        time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                        weight = oneTrayWeight,
                        CreateTime = DateTime.Now.AddHours(8)
                    }, "packageInfoModel");
                }
                catch (Exception ex)
                {
                    CMMLog.Error($"packageInfo Error:{ex.Message}");
                }
            }

        }

        public static void updatePackageInfo(string machince, string trayCode, int[] result)
        {
            if (packageCont == "1")
            {
                try
                {
                    var queryList = MongoDBSingleton.Instance.Find<packageInfoModel>(Query.And(Query.EQ("machineNo", machince), Query.EQ("trayCode", trayCode), Query.EQ("weight2", "")), "packageInfoModel");
                    if (queryList.Count > 0)
                    {
                        packageInfoModel query = queryList.OrderByDescending(a => a.time).First();
                        if (query != null)
                        {
                            CMMLog.Debug($"updatePackageInfo:{query.machineNo},trayCode:{query.trayCode},weight:{query.weight}");
                            //读取复称平台的重量 result[17]) + PLCControl.Completion(result[18]
                            double x = (double)Convert.ToInt32(PLCControl.Completion(result[19]) + PLCControl.Completion(result[20]), 2) / 100;
                            string weight = x.ToString();
                            CMMLog.Debug($"updatePackageInfo:原始复称重量数据：{result[19]},{result[20]};转换后复称重量数据：{weight}");

                            //重量差值
                            //string weightDifference = (double.Parse(query.weight) - x).ToString();
                            string weightDifference = Math.Round((double.Parse(query.weight) - x), 2).ToString();
                            //CMMLog.Info($"weightDifference2:{weightDifference2}");

                            //将复称平台重量写入中间表
                            MongoDBSingleton.Instance.Update<packageInfoModel>(Query.And(Query.EQ("machineNo", machince), Query.EQ("time", query.time), Query.EQ("trayCode", query.trayCode), Query.EQ("weight2", "")), Update.Set("weight2", weight).Set("weightDifference", weightDifference), UpdateFlags.None);

                        }
                        else CMMLog.Debug($"数据查询失败");
                    }
                    else CMMLog.Debug($"updatePackageInfo:packageInfoModel未找到数据，machineNo:{machince},trayCode:{trayCode}");
                }
                catch (Exception ex)
                {
                    CMMLog.Error($"updatePackageInfo Error:{ex.Message}");
                }
            }
        }

        public static void deletePackageInfo()
        {
            if (packageCont == "1")
            {
                try
                {
                    var request = MongoDBSingleton.Instance.FindAll<packageInfoModel>();
                    if (request.Count > 0)
                    {
                        request.ForEach(a =>
                        {
                            if (DateTime.Now.Subtract(a.CreateTime).TotalDays > 7)
                            {
                                MongoDBSingleton.Instance.Remove<packageInfoModel>(Query.EQ("_id", a._id), "packageInfoModel", RemoveFlags.None);
                            }
                        });
                    }
                }
                catch (Exception ex)
                {
                    CMMLog.Error($"deletePackageInfo Error:{ex.Message}");
                }

            }
        }

        internal static void insertMidTable()
        {
            var db = new SqlHelper<object>().GetInstance(false);
            bool resul = false;
            
            //CMMLog.Info($"查询【T_JY_MATERIALSync】表，查询条件：a.FWorkShopNumber == BM000161 && a.FUseOrgNumber == 02");
            var materInfo = db.Queryable<T_JY_MATERIALSync>().Where(a => a.FWorkShopNumber == "BM000161" && a.FUseOrgNumber == "02").ToList();
            if (materInfo.Count > 0)
            {
                //CMMLog.Info($"查询【T_JY_MATERIALSync】的数量为:{materInfo.Count}");
                var itemList = MongoDBSingleton.Instance.FindAll<ERPItemTable>();
                if (itemList.Count != materInfo.Count)
                {
                    MongoDBSingleton.Instance.RemoveAll<ERPItemTable>("ERPItemTable");
                }
            
                foreach (var a in materInfo)
                {
                    var itemInfo = MongoDBSingleton.Instance.FindOne<ERPItemTable>(Query.EQ("item_code", a.FNumber), "ERPItemTable");
                    if (itemInfo == null)
                    {
                        CMMLog.Info($"中间表【ERPItemTable】未查询到数据，物料编码：{a.FNumber}");
                        int itemNo = 1;
                        // 获取最大序号的数据
                        var maxErpItemInfoList = MongoDBSingleton.Instance.FindAll<ERPItemTable>("ERPItemTable");
                        if (maxErpItemInfoList.Count > 0)
                        {
                            var maxErpItemInfo = maxErpItemInfoList.OrderByDescending(it => it.item_no).First();
                            if (maxErpItemInfo != null) itemNo = maxErpItemInfo.item_no + 1;
                        }
            
                        CMMLog.Info($"获取插入序号：{itemNo}");
                        MongoDBSingleton.Instance.Insert<ERPItemTable>(new ERPItemTable
                        {
                            item_no = itemNo,
                            item_code = a.FNumber,
                            item_name = a.FName,
                            item_spec = a.FSpecification,
                            item_uom = a.FStoreUnit,
                            dateTime = DateTime.Now
                        }, "ERPItemTable");
                        resul = true;
                    }
                    else
                    {
                        //查询数据是否相同
                        if (itemInfo.item_name != a.FName || itemInfo.item_spec != a.FSpecification || itemInfo.item_uom != a.FStoreUnit)
                        {
                            var query = Query.EQ("item_code", a.FName);
                            var update = Update.Set("item_name", a.FName).Set("item_spec", a.FSpecification)
                            .Set("item_uom", a.FStoreUnit).Set("dateTime", DateTime.Now);
                            MongoDBSingleton.Instance.Update<ERPItemTable>(query, update, "ERPItemTable", MongoDB.Driver.UpdateFlags.None);
                            resul = true;
                        }
                    }
                }
            }
            
            var empInfo = db.Queryable<T_JY_EMPINFOSync>().ToList();
            if (empInfo.Count > 0)
            {
                var empList = MongoDBSingleton.Instance.FindAll<ERPEmployeeTable>();
                if (empList.Count != empInfo.Count)
                {
                    MongoDBSingleton.Instance.RemoveAll<ERPEmployeeTable>("ERPEmployeeTable");
                }
                foreach (var a in empInfo)
                {
                    var erpEmpInfo = MongoDBSingleton.Instance.FindOne<ERPEmployeeTable>(Query.EQ("item_code", a.FNumber), "ERPEmployeeTable");
                    if (erpEmpInfo == null)
                    {
                        CMMLog.Info($"中间表【ERPEmployeeTable】未查询到数据，物料编码：{a.FNumber}");
                        int itemNo = 1;
                        // 获取最大序号的数据
                        var maxErpEmpInfoList = MongoDBSingleton.Instance.FindAll<ERPEmployeeTable>("ERPEmployeeTable");
                        if (maxErpEmpInfoList.Count > 0)
                        {
                            var maxErpEmpInfo = maxErpEmpInfoList.OrderByDescending(it => it.item_no).First();
                            if (maxErpEmpInfo != null) itemNo = maxErpEmpInfo.item_no + 1;
                        }
            
                        CMMLog.Info($"获取插入序号：{itemNo}");
                        MongoDBSingleton.Instance.Insert<ERPEmployeeTable>(new ERPEmployeeTable
                        {
                            item_no = itemNo,
                            item_code = a.FNumber,
                            item_name = a.FName,
                            employee_id = a.FStaffNumber,
                            dateTime = DateTime.Now
                        }, "ERPEmployeeTable");
            
                        resul = true;
                    }
                    else
                    {
                        if (erpEmpInfo.employee_id != a.FStaffNumber)
                        {
                            var query = Query.EQ("item_code", a.FNumber);
                            var update = Update.Set("item_name", a.FName).Set("employee_id", a.FStaffNumber)
                            .Set("dateTime", DateTime.Now);
                            MongoDBSingleton.Instance.Update<ERPEmployeeTable>(query, update, "ERPEmployeeTable", MongoDB.Driver.UpdateFlags.None);
            
                            resul = true;
                        }
                    }
                }
            }
            if (resul)
            {
                if (!ERPService.WriteEmpAndItemInfoTwo())
                {
                    //清空表数据
                    MongoDBSingleton.Instance.RemoveAll<ERPItemTable>("ERPItemTable");
                    MongoDBSingleton.Instance.RemoveAll<ERPEmployeeTable>("ERPEmployeeTable");
                }
            }
        }

        internal static bool WriteEmpAndItemInfoTwo()
        {
            try
            {
                TcpClient client = new TcpClient("10.50.65.30", 3001);

                CMMLog.Info("WriteEmpAndItemInfoTwo 已连接到服务器");
                NetworkStream stream = client.GetStream();
                List<byte> paddedData = new List<byte>();
                var encode = Encoding.GetEncoding("GB2312");
                int i = 0;
                while (i < 150)
                {
                    if (i < 100)
                    {
                        //员工编号
                        var erpInfo = MongoDBSingleton.Instance.FindOne<ERPEmployeeTable>(Query.EQ("item_no", i + 1), "ERPEmployeeTable");
                        if (erpInfo != null && !string.IsNullOrEmpty(erpInfo.employee_id))
                        {
                            // 内存地址 0~4 协议地址 1~5 计量单位
                            byte[] data1 = encode.GetBytes(erpInfo.employee_id);
                            byte[] paddedData1 = new byte[10];
                        
                            Array.Copy(data1, 0, paddedData1, 0, Math.Min(data1.Length, 10));
                        
                            // 将数组转换为列表
                            paddedData.AddRange(paddedData1);
                        }
                        else
                        {
                            paddedData.AddRange(new byte[10]);
                        }
                    }
                    else
                    {
                        int itemNo = i - 99;
                        //物料信息
                        var itemInfo = MongoDBSingleton.Instance.FindOne<ERPItemTable>(Query.EQ("item_no", itemNo), "ERPItemTable");
                        if (itemInfo != null)
                        {
                            // 将数组转换为列表
                            paddedData.AddRange(getBuff(itemInfo.item_spec, 20, 2));

                            paddedData.AddRange(getBuff(itemInfo.item_code, 40, 1));

                            paddedData.AddRange(getBuff(itemInfo.item_name, 30, 3));

                            paddedData.AddRange(getBuff(itemInfo.item_uom, 10, 1));

                        }
                        else
                        {
                            paddedData.AddRange(new byte[100]);
                        }
                    }
                    i++;
                }

                byte[] combinedArray = paddedData.ToArray();

                stream.Write(combinedArray, 0, combinedArray.Length);
                CMMLog.Info("WriteEmpAndItemInfoTwo：" + JsonConvert.SerializeObject(combinedArray));
                //CMMLog.Info($"WriteEmpAndItemInfoTwo {combinedArray.Length}");

                //CMMLog.Info($"Received: {encode.GetString(combinedArray, 0, 6000)}");
                return true;
            }
            catch (Exception ex)
            {
                CMMLog.Info("WriteEmpAndItemInfoTwo err:" + ex.Message);
                return false;
                //WriteEmpAndItemInfoTwo();
            }
        }

        private static byte[] getBuff(string value, int bit, int result)
        {
            byte[] data1 = Encoding.GetEncoding("GB2312").GetBytes(value);
            if (result == 2) data1 = Encoding.UTF8.GetBytes(value);
            if (result == 3) data1 = Encoding.BigEndianUnicode.GetBytes(value);
            byte[] paddedData1 = new byte[bit];
            Array.Copy(data1, 0, paddedData1, 0, Math.Min(data1.Length, bit)); // 将数据复制到6000字节的缓冲区中
            return paddedData1;
        }

        internal static void senderpTask(TimeCuoInfoCom time, string startBit)
        {
            try
            {
                CMMLog.Info("插入SendErpTaskInfoTable 表 开始:" + JsonConvert.SerializeObject(time));
                var erpInfo = MongoDBSingleton.Instance.FindOne<SendErpTaskInfoTable>(Query.EQ("timeStamp", time.timeStamp.ToString()), "SendErpTaskInfoTable");
                if (erpInfo == null)
                {
                    //string fEntryId = time.FEntryID_1.ToString() + (time.FEntryID_2 == 0 ? "" : ";" + time.FEntryID_2.ToString()) + (time.FEntryID_3 == 0 ? "" : ";" + time.FEntryID_3.ToString()) + (time.FEntryID_4 == 0 ? "" : ";" + time.FEntryID_4.ToString());

                    CMMLog.Info("插入SendErpTaskInfoTable 表 1");
                    MongoDBSingleton.Instance.Insert<SendErpTaskInfoTable>(new SendErpTaskInfoTable
                    {
                        Bit = startBit,
                        packingMachineNumber = time.packingMachineNumber,
                        bagNumber1 = time.bagNumber_1,
                        bagNumber2 = time.bagNumber_2,
                        bagNumber3 = time.bagNumber_3,
                        bagNumber4 = time.bagNumber_4,
                        materiCode = time.materialCode,
                        materiName = time.materialName,
                        materialSpec = time.productModel,
                        lotCode = time.batchNumber,
                        totalWeight = time.totalWeight,
                        timeStamp = time.timeStamp.ToString(),
                        productTime = Convert.ToDateTime(time.ProductionDate).AddHours(8),
                        invalidationTime = Convert.ToDateTime(time.ProductionDate).AddHours(8).AddDays(365),
                        dateTime = DateTime.Now.AddHours(8),
                        //变更注释
                        orderCode = time.orderCode,
                        totalNeedWeight = time.needWeight,
                        netWeight = time.realWeight,
                        FEntryID = time.FEntryID_1,
                        mesSucess = "0"
                    }, "SendErpTaskInfoTable");
                }

                CMMLog.Info("插入SendErpTaskInfoTable 表 结束");
            }
            catch(Exception ex)
            {

                CMMLog.Info("插入SendErpTaskInfoTable 表 err:"+ex.Message);
            }
            
        }

        internal static void SendERPTaskInfoTwo(TN_I_TASK_MST mst)
        {
            CMMLog.Info($"任务取消，删除SendErpTaskInfoTable表数据，任务号：{mst.CN_S_TASK_NO}");
            MongoDBSingleton.Instance.Remove<SendErpTaskInfoTable>(Query.EQ("taskNo", mst.CN_S_TASK_NO),RemoveFlags.None);
        }

        internal static void SendMESTaskCompleteFunc()
        {
            var mesInfo = MongoDBSingleton.Instance.FindAll<SendMESTaskInfoTable>("SendMESTaskInfoTable");
            if(mesInfo.Count > 0)
            {
                for(int i  = mesInfo.Count - 1; i >= 0; i--)
                {
                    bool result = sendMes(mesInfo[i],false);
                    if (result)
                    {
                        MongoDBSingleton.Instance.Remove<SendMESTaskInfoTable>(Query.EQ("_id", mesInfo[i]._id), RemoveFlags.Single);
                    }
                }
            }

        }

        internal static bool senderpTaskDG(string startBit, string trayCode)
        {
            try
            {
                //通过托盘号调用wms接口获取物料信息

                CMMLog.Info("SendErpTaskInfoTableDG 表查询 开始:" + startBit);
                var url = hao.WebUrl + "GlmTrayItemSet";
                var erpInfo = MongoDBSingleton.Instance.FindOne<SendErpTaskInfoTableDG>(Query.EQ("Bit", startBit), "SendErpTaskInfoTableDG");
                if (erpInfo == null)
                {
                    //string fEntryId = time.FEntryID_1.ToString() + (time.FEntryID_2 == 0 ? "" : ";" + time.FEntryID_2.ToString()) + (time.FEntryID_3 == 0 ? "" : ";" + time.FEntryID_3.ToString()) + (time.FEntryID_4 == 0 ? "" : ";" + time.FEntryID_4.ToString());
                    string materiCode = "";
                    string lotCode = "";
                    int totalWeight = 0;
                    string productTime = "";

                    //根据托盘号获取入库物料信息
                    CJWareNum model = new CJWareNum
                    {
                        TrayCode = trayCode
                    };

                    string msgData = JsonConvert.SerializeObject(model);

                    var feedback = helper.WebPost(url, msgData).Replace(@"\", "").Trim();
                    CMMLog.Info($"SendErpTaskInfoTableDG:【调用wms获取物料信息】:接收数据：" + feedback);
                    if (!string.IsNullOrEmpty(feedback))
                    {
                        var wmsResponse = JsonConvert.DeserializeObject<LKInfoResModel>(feedback);
                        if (wmsResponse.Success == true)
                        {
                            materiCode = wmsResponse.Data.CN_S_ITEM_CODE;
                            lotCode = wmsResponse.Data.CN_S_LOT_NO;
                            totalWeight = (int)wmsResponse.Data.CN_F_QUANTITY * wmsResponse.Data.CN_N_CONUT;
                            productTime = wmsResponse.Data.CN_T_PRODUCTION_S;
                        }
                    }

                    CMMLog.Info("SendErpTaskInfoTableDG表 1");
                    if (!string.IsNullOrEmpty(materiCode) && !string.IsNullOrEmpty(lotCode) && totalWeight != 0 && !string.IsNullOrEmpty(productTime))
                    {
                        MongoDBSingleton.Instance.Insert<SendErpTaskInfoTableDG>(new SendErpTaskInfoTableDG
                        {
                            Bit = startBit,
                            materiCode = materiCode,
                            lotCode = lotCode,
                            totalWeight = totalWeight,
                            productTime = Convert.ToDateTime(productTime).AddHours(8),
                            invalidationTime = Convert.ToDateTime(productTime).AddHours(8).AddDays(365),
                            dateTime = DateTime.Now.AddHours(8),
                            //变更注释
                            mesSucess = "0"
                        }, "SendErpTaskInfoTableDG");
                        return true;
                    }
                    else
                    {
                        CMMLog.Info($"SendErpTaskInfoTableDG:获取数据错误，materiCode：{materiCode},lotCode:{lotCode},totalWeight:{totalWeight},productTime:{productTime}");
                    }
                    
                }

                CMMLog.Info("插入SendErpTaskInfoTableDG表 结束");
            }
            catch (Exception ex)
            {

                CMMLog.Info("插入SendErpTaskInfoTableDG表 err:" + ex.Message);
            }

            return false;
        }

        internal static void SendERPTaskCompleteFuncDG()
        {

            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var sendERPTaskInfoList = MongoDBSingleton.Instance.Find<SendErpTaskInfoTableDG>(Query.And(Query.EQ("isFinish", "Y"), Query.EQ("mesSucess", "0")), "SendErpTaskInfoTableDG");
                if (sendERPTaskInfoList.Count > 0)
                {
                    var timeInfo = sendERPTaskInfoList.OrderBy(a => a.dateTime).First();
                    CMMLog.Info($"SendERPTaskCompleteFunc:{sendERPTaskInfoList.Count}");
                    CMMLog.Info($"SendERPTaskCompleteFunc:{timeInfo.dateTime.AddHours(1) < DateTime.Now}");
                    if (sendERPTaskInfoList.Count == 5 || timeInfo.dateTime.AddHours(1) < DateTime.Now)
                    {
                        // 先根据任务批次号字段获取时间戳中间表-TimeCuoInfoCom 数据，并进行后续调用，处理成功删除时间戳中间表-TimeCuoInfoCom 数据

                        int n = 0; //行号
                        sendERPTaskInfoList.ForEach(a =>
                        {
                            n = n + 1;
                            #region 计算单据编号
                            string FBillNO = "";
                            int num = 0;
                            string S_NUM = "";
                            string time = DateTime.Now.ToString("yyMMdd");
                            CMMLog.Info($"SendERPTaskCompleteFunc time：{time}");
                            var midInfo = db.Queryable<ADDMid>().Where(b => b.time == time).First();
                            if (midInfo != null)
                            {
                                midInfo.num = midInfo.num + 1;
                                num = midInfo.num;
                                db.Updateable(midInfo).UpdateColumns(b => new { b.num }).ExecuteCommand();
                            }
                            else
                            {
                                num = 1;
                                midInfo = new ADDMid
                                {
                                    time = DateTime.Now.ToString("yyMMdd"),
                                    num = 1
                                };
                                db.Insertable(midInfo).ExecuteCommand();
                            }

                            CMMLog.Info($"SendERPTaskCompleteFunc num: {num}");
                            for (int i = num.ToString().Length + 1; i <= 4; i++)
                            {
                                S_NUM = S_NUM + "0";
                            }

                            FBillNO = "ARKD" + DateTime.Now.ToString("yyMMdd") + S_NUM + num.ToString();
                            CMMLog.Info($"SendERPTaskCompleteFunc: {FBillNO}");
                            #endregion

                            CMMLog.Info($"SendERPTaskCompleteFunc:INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','G0200400','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}',{sendERPTaskInfoList.Count},'0')");
                            string sql = $"INSERT INTO T_JY_SPInStockADD (FBillNO,FStockOrgNumber,FPrdOrgNumber,FSeq,FMaterialNumber,Flot,FInStockType,FMustQty,FStockNumber,FWorkShopNumber,FStockStatus,FProduceDate ,FExpiryDate,FTaskNumber,FCountEntry,FOpStatus) VALUES ('{FBillNO}','02','02','{n}','{a.materiCode}','{a.lotCode}','1','{a.totalWeight}','CK020','G0200400','1','{a.productTime}','{a.invalidationTime}','{a.taskNo}',{sendERPTaskInfoList.Count},'0')";
                            if (new SqlHelper<object>().ExecuteSql(sql, false))
                            {
                                //插入成功 清除中间表
                                MongoDBSingleton.Instance.Remove<SendErpTaskInfoTableDG>(Query.EQ("_id", a._id), "SendErpTaskInfoTableDG", RemoveFlags.None);
                            }
                            else
                            {
                                //插入失败，将数据插入新表，人工手动处理，重新插入
                                //MongoDBSingleton.Instance.Insert<SendErpTaskInfoTableBak>(new SendErpTaskInfoTableBak
                                //{
                                //    orderCode = a.orderCode,
                                //    FEntryID = a.FEntryID,
                                //    totalNeedWeight = a.totalNeedWeight,
                                //    lotCode = a.lotCode,
                                //    productTime = a.productTime,
                                //    invalidationTime = a.invalidationTime,
                                //    taskNo = a.taskNo
                                //}, "SendErpTaskInfoTableBak");
                            }
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                CMMLog.Info("SendERPTaskCompleteFunc err:" + ex.Message);
            }
        }

        public class packageInfoModel
        {
            public ObjectId _id { get; set; }
            /// <summary>
            /// 包装机号
            /// </summary>
            public string machineNo { get; set; } = "";
            /// <summary>
            /// 托盘号
            /// </summary>
            public string trayCode { get; set; } = "";
            /// <summary>
            /// 批次号
            /// </summary>
            public string batchNo { get; set; } = "";
            /// <summary>
            /// 下料时间
            /// </summary>
            public string time { get; set; } = "";
            /// <summary>
            /// 重量
            /// </summary>
            public string weight { get; set; } = "";
            /// <summary>
            /// 复称重量
            /// </summary>
            public string weight2 { get; set; } = "";
            /// <summary>
            /// 重量差值
            /// </summary>
            public string weightDifference { get; set; } = "";
            /// <summary>
            /// 创建时间
            /// </summary>
            public DateTime CreateTime { get; set; }
        }

    }
}