using HH.WCS.NongFuChaYuan.DeviceService;
using HH.WCS.NongFuChaYuan.TaskController;
using HH.WCS.NongFuChaYuan.OtherService;
using HH.WCS.NongFuChaYuan.WmsService;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;
using HH.WCS.NongFuChaYuan.DispatchService;
using SqlSugar;

namespace HH.WCS.NongFuChaYuan.TaskController
{
    /// <summary>
    /// 定时轮询任务
    /// </summary>
    internal class Monitor
    {
        private static ModbusHelper modbusHelper = new ModbusHelper();
        private static WCSHelper WCSHelper = new WCSHelper();

        #region   农夫山泉-大明山工厂








        /// <summary>
        /// 自动移库 从0点开始移库(前一天的批次号)
        /// </summary>
        public static void AnalysisProductLine()
        {
            //查找前一天的中间表数据
            var db = new SqlHelper<object>().GetInstance();
            var oldbatch = DateTime.Now.AddDays(-1).ToString("yyyyMMdd").Substring(2);
            var newbatch = DateTime.Now.ToString("yyyyMMdd").Substring(2);
            LogHelper.Info($"昨天批次={oldbatch},当天批次={newbatch}", "自动移库");
            var movelist = db.Queryable<DaMingShanAnalysisMoveLib>().Where(a => a.Batch.Contains(oldbatch)).ToList();
            if (movelist.Count > 0)
            {
                if (DateTime.Now > DateTime.Parse("9:30"))
                {
                    LogHelper.Info($"中间表查找到前一天的批次 开始查找自动移库工单进行移库", "自动移库");
                    //查找工单 如果状态为执行中则开始移库
                    var worklist = movelist.GroupBy(a => a.DeviceName).ToList();
                    for (int k = 0; k < worklist.Count(); k++)
                    {
                        var deviceinfo = worklist[k].OrderBy(a => a.DeviceName).First();
                        var fulenewbatch = "";
                        var fuleoldbatch = "";
                        if (deviceinfo.DeviceName.Contains("SL1"))
                        {
                            fulenewbatch = newbatch + "SL1";
                            fuleoldbatch = oldbatch + "SL1";
                        }
                        else
                        {
                            fulenewbatch = newbatch + "SL2";
                            fuleoldbatch = oldbatch + "SL2";
                        }
                        var WorkInfo = WCSHelper.GetDaMingShanAnalysisOrderWorkType("自动移库", fulenewbatch, deviceinfo.DeviceName);
                        if (WorkInfo.Count > 0)
                        {
                            var rowlist = new List<string>();
                            var oldrowlist = new List<string>();
                            LogHelper.Info($"查找到自动移库工单 判断状态是否是执行中", "自动移库");
                            var state = WorkInfo.Where(a => a.S_WorkState == "执行中").ToList();
                            if (state.Count > 0)
                            {
                                //执行移库 将产线分开进行移库
                                for (int i = 0; i < state.Count; i++)
                                {
                                    var list = movelist.Where(a => a.DeviceName == state[i].S_PLineNo).ToList();
                                    //拿出中间表记录的排数据
                                    for (int j = 0; j < list.Count; j++)
                                    {
                                        rowlist.Add(list[j].RowNo);
                                        oldrowlist.Add(list[j].RowNo);
                                    }
                                    //判断这条产线对应的排有没有任务
                                    if (IntensiveArea.TaskTakeAreaOver2(rowlist))
                                    {
                                        //排除放满的排和空的排并解锁
                                        LogHelper.Info($"产线 {list[0].DeviceName} 下线的所有排为{JsonConvert.SerializeObject(rowlist)}", "自动移库");
                                        IntensiveArea.ExcludeFullEmyRow(ref rowlist, state[i].S_PLineNo);
                                        if (rowlist.Count() >= 2)
                                        {
                                            LogHelper.Info($"产线 {list[0].DeviceName} 经过空满判断排除过后 剩下的所有排为{JsonConvert.SerializeObject(rowlist)}", "自动移库");
                                            //锁定剩下的排 排除货位有锁的情况
                                            IntensiveArea.LockYiKu(ref rowlist);
                                            LogHelper.Info($"产线 {list[0].DeviceName} 经过锁定排除过后 剩下的所有排为{JsonConvert.SerializeObject(rowlist)}", "自动移库");
                                            //剩下的排进行物料匹配生成任务
                                            var res = IntensiveArea.GetYiKuLocation(rowlist, state[i], fuleoldbatch);
                                            if (!res && oldrowlist.Count() == rowlist.Count())
                                            {
                                                //结束工单并删除中间表数据
                                                WCSHelper.EndYiKuWorkOrder(state[i].S_PLineNo, state[i].S_BatchNo, oldbatch);
                                                foreach (var item in rowlist)
                                                {
                                                    IntensiveArea.UnlockYiKu(item);
                                                }
                                            }
                                        }
                                        else
                                        {
                                            //结束工单删除中间表数据
                                            WCSHelper.EndYiKuWorkOrder(state[i].S_PLineNo, state[i].S_BatchNo, oldbatch);
                                            foreach (var item in rowlist)
                                            {
                                                IntensiveArea.UnlockYiKu(item);
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                LogHelper.Info($"自动移库工单状态不为执行中 可能已完成或暂停 详情看mobox工单管理", "自动移库");
                            }
                        }
                        else
                        {
                            LogHelper.Info($"没有查找到当天的自动移库工单 自动创建自动移库工单", "自动移库");
                            //创建自动移库工单
                            WorkOrder workorder = new WorkOrder
                            {
                                S_WorkNo = deviceinfo.Batch + "00" + (k + 1).ToString(),
                                S_PLineNo = deviceinfo.DeviceName,
                                S_BatchNo = fulenewbatch,
                                S_ORDER_TYPE = "自动移库",
                                S_WorkState = "执行中"
                            };
                            WCSHelper.DaMingShanInsertWork(workorder);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 备货移库
        /// </summary>
        internal static void AnalysisStockup()
        {
            var WorkInfo = WCSHelper.GetDaMingShanAnalysisOrderWork("备货移库");
            if (WorkInfo != null)
            {
                AnalysisCularAndStock1(WorkInfo);
            }
        }


        /// <summary>
        /// 更新实时库存
        /// </summary>
        internal static void PanKurealtime()
        {
            var db = new SqlHelper<object>().GetInstance();
            var list = Settings.GetPanKuList();
            if (list.Count() > 0)
            {
                list.ForEach(b =>
                {
                    var collist = db.Queryable<Location>().Where(a => a.S_AREA_CODE == b).PartitionBy(a => a.N_ROW).OrderByDescending(a => a.N_COL).Take(1).ToList();
                    collist.ForEach(c =>
                    {
                        var locinfo = db.Queryable<Location>().Where(a => a.N_ROW == c.N_ROW && a.N_CURRENT_NUM > 0).First();
                        if (locinfo == null)
                        {
                            var pankuinfo = db.Queryable<DaMingShanPanKuTask>().Where(a => a.N_ROW == c.N_ROW).First();
                            if (pankuinfo == null)
                            {
                                //插入盘库数据
                                LogHelper.Info($"插入空排数据");
                                var pk = new DaMingShanPanKuTask
                                {
                                    N_CURRENT_NUM = 0,
                                    N_ROW = c.N_ROW,
                                    S_AREA_CODE = b
                                };
                                db.Insertable(pk).ExecuteCommand();
                            }
                            else
                            {
                                //更新盘库数据中间表
                                LogHelper.Info($"更新空排数据");
                                pankuinfo.N_CURRENT_NUM = 0;
                                pankuinfo.S_BatchNo = "";
                                pankuinfo.SQL_Condition = "";
                                pankuinfo.S_ItemCode = "";
                                pankuinfo.S_PLineNo = "";
                                pankuinfo.S_AREA_CODE = b;
                                db.Updateable(pankuinfo).WhereColumns(a => new { a.S_ID }).ExecuteCommand();
                            }
                        }
                        else
                        {
                            var iteminfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locinfo.S_LOC_CODE).Includes(a => a.CntrItemRel).First();
                            var numinfo = db.Queryable<Location>().Where(a => a.N_ROW == c.N_ROW).Select(a => new { sum = SqlFunc.AggregateSum(a.N_CURRENT_NUM) }).First();
                            var condition = WCSHelper.GetItemrel(iteminfo.CntrItemRel.S_ITEM_CODE, iteminfo.CntrItemRel.S_ITEM_MODEL);
                            var pankuinfo = db.Queryable<DaMingShanPanKuTask>().Where(a => a.N_ROW == c.N_ROW).First();
                            if (iteminfo != null && numinfo != null && condition != null)
                            {
                                if (pankuinfo == null)
                                {
                                    //插入盘库数据
                                    LogHelper.Info($"插入非空排数据");
                                    var pk = new DaMingShanPanKuTask
                                    {
                                        N_ROW = c.N_ROW,
                                        N_CURRENT_NUM = numinfo.sum * 2,
                                        S_BatchNo = iteminfo.CntrItemRel.S_BATCH_NO,
                                        SQL_Condition = condition.S_ITEM_CODE,
                                        S_ItemCode = iteminfo.CntrItemRel.S_ITEM_CODE,
                                        S_PLineNo = iteminfo.S_SRC == "一号输送线" ? "SL1" : "SL2",
                                        S_AREA_CODE = b
                                    };
                                    db.Insertable(pk).ExecuteCommand();
                                }
                                else
                                {
                                    //更新盘库数据中间表
                                    LogHelper.Info($"更新非空排数据");
                                    pankuinfo.N_CURRENT_NUM = numinfo.sum * 2;
                                    pankuinfo.S_BatchNo = iteminfo.CntrItemRel.S_BATCH_NO;
                                    pankuinfo.SQL_Condition = condition.S_ITEM_CODE;
                                    pankuinfo.S_ItemCode = iteminfo.CntrItemRel.S_ITEM_CODE;
                                    pankuinfo.S_PLineNo = iteminfo.S_SRC == "一号输送线" ? "SL1" : "SL2";
                                    pankuinfo.S_AREA_CODE = b;
                                    db.Updateable(pankuinfo).WhereColumns(a => new { a.S_ID }).ExecuteCommand();
                                }
                            }
                        }
                    });
                });
            }
        }


        /// <summary>
        /// 瓶盖机非即产即用
        /// </summary>
        internal static void AnalysisMoveLib()
        {
            ////瓶盖机
            //PingGaikkcontrel();
            //Thread.Sleep(1000);
            //PingGaiN();
            //Thread.Sleep(1000);
            //PingGaiIncontrel();
            //Thread.Sleep(1000);
            ////瓶盖翻斗机
            //FanDoukkcontrel();
            //Thread.Sleep(1000);
            //FanDouN();
            //Thread.Sleep(1000);
            //FanDouIncontrel();

            ZiDong();
            Thread.Sleep(1000);
            itemZiDong();
            Thread.Sleep(1000);


        }

        private static void itemZiDong()
        {
            var db = new SqlHelper<object>().GetInstance();
            string areaNo = "YWJGJBQ";
            var startbitlist = db.Queryable<Location>()
                .Where(a => a.S_AREA_CODE == areaNo && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE=="无")
                .PartitionBy(a => a.N_ROW)
                .OrderByDescending(a => a.N_COL)
                .Includes(a => a.LocCntrRel, b => b.CntrItemRel)
                .Take(1)
                .ToList();
            foreach (var item in startbitlist)
            {
                var startlock = db.Queryable<Location>()
                    .Where(a => a.S_AREA_CODE == item.S_AREA_CODE && a.N_ROW == item.N_ROW && a.S_LOCK_STATE != "无" && a.S_LOCK_STATE != "报废")
                    .First();
                if (startlock == null)
                {
                    //算取终点
                    if (item.LocCntrRel != null && !string.IsNullOrEmpty(item.LocCntrRel.S_CNTR_CODE))
                    {
                        if (item.LocCntrRel.CntrItemRel != null)
                        {
                            string itemcode = item.LocCntrRel.CntrItemRel.S_ITEM_CODE;
                            var info = Settings.GetItemCacheAreaList().Where(a => a.ItemCode == itemcode).FirstOrDefault();
                            if (info != null)
                            {
                                string endarea = info.AreaCode;
                                var endbitlist = db.Queryable<Location>()
                                    .Where(a => a.S_AREA_CODE == endarea && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE=="无")
                                    .PartitionBy(a => a.N_ROW)
                                    .OrderBy(a => a.N_COL)
                                    .Take(1)
                                    .ToList();
                                foreach (var it in endbitlist)
                                {
                                    var endlock = db.Queryable<Location>()
                                        .Where(a => a.S_AREA_CODE == it.S_AREA_CODE && a.N_ROW == it.N_ROW && a.S_LOCK_STATE != "无" && a.S_LOCK_STATE != "报废")
                                        .First();
                                    if (endlock == null) 
                                    {
                                        //创建任务
                                        IntensiveArea.DaMingShanCreateTransport(item.S_LOC_CODE, it.S_LOC_CODE, "点到点转运", item.LocCntrRel.S_CNTR_CODE, 1, 1, "", 1);
                                        break;
                                    }
                                }
                            }
                            else 
                            {
                                LogHelper.Info($"物料{itemcode} 未在配置中找到对应库区");
                            }
                        }
                        else 
                        {
                            LogHelper.Info($"货位{item.S_LOC_CODE} 托盘{item.LocCntrRel.S_CNTR_CODE} 未绑定物料");
                        }
                    }
                    else 
                    {
                        LogHelper.Info($"货位{item.S_LOC_CODE} 未绑定托盘");
                    }
                }
            }
        }

        private static void ZiDong()
        {
            var db = new SqlHelper<object>().GetInstance();
            var list = Settings.GetinStockCacheAreaList().Where(a => a.Enable == "1").ToList();
            if (list.Count > 0)
            {
                list.ForEach(a =>
                {
                    try
                    {
                        if (!string.IsNullOrEmpty(a.deviceName))
                        {
                            LogHelper.Info($"自动转运 工单号={a.deviceName}");
                            var workorder = db.Queryable<PGWorkOrder>().Where(it => it.S_PLineNo == a.deviceName && it.S_WorkState == "执行中").First();
                            if (workorder != null)
                            {
                                var num = 0;
                                if (workorder.S_PLineNo == "Y7坯" || workorder.S_PLineNo == "Y8坯" || workorder.S_PLineNo == "Y8盖")
                                {
                                    //判断终点数量小于3
                                    var areanum = db.Queryable<Location>().Where(it => it.S_AREA_CODE == a.ProductArea).Select(it => new { sum = SqlFunc.AggregateSum(it.N_CURRENT_NUM) }).First().sum;
                                    var locknum = db.Queryable<Location>().Where(it => it.S_AREA_CODE == a.ProductArea && it.S_LOCK_STATE == "入库锁").ToList().Count();
                                    num = num + areanum + locknum;
                                }

                                if (num < 3)
                                {
                                    LogHelper.Info($"自动转运 查找到工单 工单号={workorder.S_WorkNo}");
                                    if (a.CacheAreaNoLock == "1")
                                    {
                                        var loclist = db.Queryable<Location>()
                                       .Where(it => it.S_AREA_CODE == a.CacheAreaNo && it.N_CURRENT_NUM > 0 && it.S_LOCK_STATE == "无")
                                       .Select(it => new { sum = SqlFunc.AggregateSum(it.N_CURRENT_NUM), it.N_ROW })
                                       .GroupBy(it => it.N_ROW)
                                       .MergeTable()
                                       .OrderByDescending(it => it.sum)
                                       .ToList();

                                        if (loclist.Count > 0)
                                        {
                                            LogHelper.Info($"起点货位数量大于0的货位数量={loclist.Count}");
                                            var locinfo = db.Queryable<Location>()
                                                .Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                                .First();
                                            if (locinfo != null)
                                            {
                                                var trayNo = "";
                                                foreach (var item in loclist)
                                                {
                                                    if (a.ProductAreaLock == "0")
                                                    {
                                                        LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock} 获取可卸货货位编码{locinfo.S_LOC_CODE} 当前数量{locinfo.N_CURRENT_NUM} 当前锁定状态{locinfo.S_LOCK_STATE}");
                                                        //终点库区非密集型库区算法
                                                        var lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == item.N_ROW && it.S_LOCK_STATE != "无").First();
                                                        if (lockinfo == null)
                                                        {
                                                            var startbit = db.Queryable<Location>()
                                                            .Where(it => it.N_ROW == item.N_ROW && it.N_CURRENT_NUM > 0)
                                                            .OrderByDescending(it => it.N_COL)
                                                            .Includes(it => it.LocCntrRel)
                                                            .First();
                                                            //创建任务
                                                            var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == startbit.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                            LogHelper.Info($"获取起点{startbit.S_LOC_CODE} 点位绑定托盘数量{traylist.Count}");

                                                            for (int i = 0; i < a.CntrCount; i++)
                                                            {
                                                                LogHelper.Info("11111111111");
                                                                trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                            }
                                                            LogHelper.Info("222222222222");
                                                            IntensiveArea.DaMingShanCreateTransport(startbit.S_LOC_CODE, locinfo.S_LOC_CODE, a.TaskType, trayNo, startbit.N_CURRENT_NUM - a.CntrCount + 1, locinfo.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                            break;
                                                        }
                                                        else
                                                        {
                                                            LogHelper.Info($"起点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                        }
                                                    }
                                                    else
                                                    {
                                                        LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock}");
                                                        //终点库区密集型库区算法
                                                        var result = false;
                                                        var endlist = db.Queryable<Location>().Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                                        .OrderBy(it => it.N_COL)
                                                        .PartitionBy(it => it.N_ROW)
                                                        .Take(1)
                                                        .ToList();
                                                        foreach (var b in endlist)
                                                        {
                                                            LogHelper.Info($"获取可卸货货位编码{b.S_LOC_CODE} 当前数量{b.N_CURRENT_NUM} 当前锁定状态{b.S_LOCK_STATE}");
                                                            var lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == b.N_ROW && it.S_LOCK_STATE != "无").First();
                                                            if (lockinfo == null)
                                                            {
                                                                lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == item.N_ROW && it.S_LOCK_STATE != "无").First();
                                                                if (lockinfo == null)
                                                                {
                                                                    var startbit = db.Queryable<Location>()
                                                                    .Where(it => it.N_ROW == item.N_ROW && it.N_CURRENT_NUM > 0)
                                                                    .OrderByDescending(it => it.N_COL)
                                                                    .Includes(it => it.LocCntrRel)
                                                                    .First();
                                                                    //创建任务
                                                                    var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == startbit.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                                    for (int i = 0; i < a.CntrCount; i++)
                                                                    {
                                                                        trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                                    }

                                                                    IntensiveArea.DaMingShanCreateTransport(startbit.S_LOC_CODE, b.S_LOC_CODE, a.TaskType, trayNo, startbit.N_CURRENT_NUM - a.CntrCount + 1, b.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                                    break;
                                                                }
                                                                else
                                                                {
                                                                    LogHelper.Info($"起点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                                    break;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                LogHelper.Info($"终点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                            }
                                                        }
                                                        if (result) break;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        var loclist = db.Queryable<Location>()
                                           .Where(it => it.S_AREA_CODE == a.CacheAreaNo && it.N_CURRENT_NUM == a.CntrCount && it.S_LOCK_STATE == "无")
                                           .Includes(it => it.LocCntrRel)
                                           .First();

                                        if (loclist != null)
                                        {
                                            LogHelper.Info($"起点货位 {loclist.S_LOC_CODE}");
                                            var locinfo = db.Queryable<Location>()
                                                .Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                                .First();
                                            if (locinfo != null)
                                            {
                                                var trayNo = "";
                                                if (a.ProductAreaLock == "0")
                                                {
                                                    LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock} 获取可卸货货位编码{locinfo.S_LOC_CODE} 当前数量{locinfo.N_CURRENT_NUM} 当前锁定状态{locinfo.S_LOCK_STATE}");
                                                    //创建任务

                                                    var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == loclist.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                    for (int i = 0; i < a.CntrCount; i++)
                                                    {
                                                        trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                    }
                                                    IntensiveArea.DaMingShanCreateTransport(loclist.S_LOC_CODE, locinfo.S_LOC_CODE, a.TaskType, trayNo, loclist.N_CURRENT_NUM - a.CntrCount + 1, locinfo.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                }
                                                else
                                                {
                                                    LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock}");
                                                    //终点库区密集型库区算法
                                                    var endlist = db.Queryable<Location>().Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                                    .OrderBy(it => it.N_COL)
                                                    .PartitionBy(it => it.N_ROW)
                                                    .Take(1)
                                                    .ToList();
                                                    foreach (var b in endlist)
                                                    {
                                                        LogHelper.Info($"获取可卸货货位编码{b.S_LOC_CODE} 当前数量{b.N_CURRENT_NUM} 当前锁定状态{b.S_LOCK_STATE}");
                                                        var lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == b.N_ROW && it.S_LOCK_STATE != "无").First();
                                                        if (lockinfo == null)
                                                        {
                                                            //创建任务
                                                            var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == loclist.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                            for (int i = 0; i < a.CntrCount; i++)
                                                            {
                                                                trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                            }
                                                            IntensiveArea.DaMingShanCreateTransport(loclist.S_LOC_CODE, b.S_LOC_CODE, a.TaskType, trayNo, loclist.N_CURRENT_NUM - a.CntrCount + 1, b.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                            break;
                                                        }
                                                        else
                                                        {
                                                            LogHelper.Info($"终点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                else
                                {

                                }
                            }
                        }
                        else
                        {
                            if (a.CacheAreaNoLock == "1")
                            {
                                var loclist = db.Queryable<Location>()
                                .Where(it => it.S_AREA_CODE == a.CacheAreaNo && it.N_CURRENT_NUM > 0)
                                .Select(it => new { sum = SqlFunc.AggregateSum(it.N_CURRENT_NUM), it.N_ROW })
                                .GroupBy(it => it.N_ROW)
                                .MergeTable()
                                .OrderByDescending(it => it.sum)
                                .ToList();

                                LogHelper.Info($"起点货位数量大于0的货位数量={loclist.Count}");
                                if (loclist.Count > 0)
                                {
                                    var locinfo = db.Queryable<Location>()
                                        .Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                        .First();
                                    if (locinfo != null)
                                    {
                                        LogHelper.Info($"查找到终点有空货位可以卸货 货位编码={locinfo.S_LOC_CODE}");
                                        var trayNo = "";
                                        foreach (var item in loclist)
                                        {
                                            if (a.ProductAreaLock == "0")
                                            {
                                                //终点库区非密集型库区算法
                                                LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock} 获取可卸货货位编码{locinfo.S_LOC_CODE} 当前数量{locinfo.N_CURRENT_NUM} 当前锁定状态{locinfo.S_LOCK_STATE}");
                                                var lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == item.N_ROW && it.S_LOCK_STATE != "无").First();
                                                if (lockinfo == null)
                                                {
                                                    var startbit = db.Queryable<Location>()
                                                                 .Where(it => it.N_ROW == item.N_ROW && it.N_CURRENT_NUM > 0 && it.S_LOCK_STATE == "无")
                                                                 .OrderByDescending(it => it.N_COL)
                                                                 .Includes(it => it.LocCntrRel)
                                                                 .First();
                                                    //创建任务

                                                    var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == startbit.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                    for (int i = 0; i < a.CntrCount; i++)
                                                    {
                                                        trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                    }
                                                    IntensiveArea.DaMingShanCreateTransport(startbit.S_LOC_CODE, locinfo.S_LOC_CODE, a.TaskType, trayNo, startbit.N_CURRENT_NUM - a.CntrCount + 1, locinfo.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                    break;
                                                }
                                                else
                                                {
                                                    LogHelper.Info($"起点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                }
                                            }
                                            else
                                            {
                                                //终点库区密集型库区算法
                                                LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock}");
                                                var result = false;
                                                var endlist = db.Queryable<Location>().Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                                .OrderBy(it => it.N_COL)
                                                .PartitionBy(it => it.N_ROW)
                                                .Take(1)
                                                .ToList();
                                                foreach (var b in endlist)
                                                {
                                                    LogHelper.Info($"获取可卸货货位编码{b.S_LOC_CODE} 当前数量{b.N_CURRENT_NUM} 当前锁定状态{b.S_LOCK_STATE}");
                                                    var lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == b.N_ROW && it.S_LOCK_STATE != "无").First();
                                                    if (lockinfo == null)
                                                    {
                                                        lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == item.N_ROW && it.S_LOCK_STATE != "无").First();
                                                        if (lockinfo == null)
                                                        {
                                                            var startbit = db.Queryable<Location>()
                                                                 .Where(it => it.N_ROW == item.N_ROW && it.N_CURRENT_NUM > 0 && it.S_LOCK_STATE == "无")
                                                                 .OrderByDescending(it => it.N_COL)
                                                                 .Includes(it => it.LocCntrRel)
                                                                 .First();
                                                            LogHelper.Info($"获取可取货货位编码{startbit.S_LOC_CODE}");
                                                            //创建任务


                                                            var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == startbit.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                            for (int i = 0; i < a.CntrCount; i++)
                                                            {
                                                                trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                            }


                                                            IntensiveArea.DaMingShanCreateTransport(startbit.S_LOC_CODE, b.S_LOC_CODE, a.TaskType, trayNo, startbit.N_CURRENT_NUM - a.CntrCount + 1, b.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                            break;
                                                        }
                                                        else
                                                        {
                                                            LogHelper.Info($"起点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                            break;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        LogHelper.Info($"终点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                    }
                                                }
                                                if (result) break;
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                var loclist = db.Queryable<Location>()
                                     .Where(it => it.S_AREA_CODE == a.CacheAreaNo && it.N_CURRENT_NUM > 0 && it.S_LOCK_STATE == "无")
                                     .Includes(it => it.LocCntrRel)
                                     .First();

                                if (loclist != null)
                                {
                                    LogHelper.Info($"起点货位 {loclist.S_LOC_CODE}");
                                    var locinfo = db.Queryable<Location>()
                                        .Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                        .First();
                                    if (locinfo != null)
                                    {
                                        LogHelper.Info($"查找到终点有空货位可以卸货 货位编码={locinfo.S_LOC_CODE}");
                                        var trayNo = "";

                                        if (a.ProductAreaLock == "0")
                                        {
                                            //终点库区非密集型库区算法
                                            LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock} 获取可卸货货位编码{locinfo.S_LOC_CODE} 当前数量{locinfo.N_CURRENT_NUM} 当前锁定状态{locinfo.S_LOCK_STATE}");

                                            //创建任务
                                            var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == loclist.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                            for (int i = 0; i < a.CntrCount; i++)
                                            {
                                                trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                            }
                                            IntensiveArea.DaMingShanCreateTransport(loclist.S_LOC_CODE, locinfo.S_LOC_CODE, a.TaskType, trayNo, loclist.N_CURRENT_NUM - a.CntrCount + 1, locinfo.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                        }
                                        else
                                        {
                                            //终点库区密集型库区算法
                                            LogHelper.Info($"终点库区{a.ProductArea} 密集类型{a.ProductAreaLock}");
                                            var endlist = db.Queryable<Location>().Where(it => it.S_AREA_CODE == a.ProductArea && it.N_CURRENT_NUM == 0 && it.S_LOCK_STATE == "无")
                                            .OrderBy(it => it.N_COL)
                                            .PartitionBy(it => it.N_ROW)
                                            .Take(1)
                                            .ToList();
                                            foreach (var b in endlist)
                                            {
                                                LogHelper.Info($"获取可卸货货位编码{b.S_LOC_CODE} 当前数量{b.N_CURRENT_NUM} 当前锁定状态{b.S_LOCK_STATE}");
                                                var lockinfo = db.Queryable<Location>().Where(it => it.N_ROW == b.N_ROW && it.S_LOCK_STATE != "无").First();
                                                if (lockinfo == null)
                                                {
                                                    LogHelper.Info($"获取可取货货位编码{loclist.S_LOC_CODE}");
                                                    //创建任务

                                                    var traylist = db.Queryable<LocCntrRel>().Where(it => it.S_LOC_CODE == loclist.S_LOC_CODE).OrderByDescending(it => it.T_CREATE).ToList();
                                                    for (int i = 0; i < a.CntrCount; i++)
                                                    {
                                                        trayNo = traylist[i].S_CNTR_CODE + "," + trayNo;
                                                    }
                                                    IntensiveArea.DaMingShanCreateTransport(loclist.S_LOC_CODE, b.S_LOC_CODE, a.TaskType, trayNo, loclist.N_CURRENT_NUM - a.CntrCount + 1, b.N_CURRENT_NUM + 1, "1", 1, a.Priority);
                                                    break;
                                                }
                                                else
                                                {
                                                    LogHelper.Info($"终点排 货位{lockinfo.S_LOC_CODE} 当前货位状态{lockinfo.S_LOCK_STATE} 不允许生成任务");
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception ex) 
                    {
                        LogHelper.Error($"自动转运流程异常 异常信息{ex.Message}",ex);
                    }

                });
            }
        }

        /// <summary>
        /// 瓶坯机非即产即用
        /// </summary>
        internal static void AnalysisMoveLib1()
        {
            //瓶坯机
            PingGaikkcontrel1();
            Thread.Sleep(1000);
            //PingGaiN1();
            //Thread.Sleep(1000);
            //PingGaiIncontrel1();
            //Thread.Sleep(1000);
            //瓶坯翻斗机
            FanDoukkcontrel1();
            //Thread.Sleep(1000);
            //FanDouN1();
            //Thread.Sleep(1000);
            //FanDouIncontrel1();
        }

        /// <summary>
        /// 管控瓶盖入库缓存位
        /// </summary>
        private static void PingGaiIncontrel()
        {
            LogHelper.Info("瓶盖入库管控");
            var db = new SqlHelper<object>().GetInstance();
            //瓶盖入库不需要工单
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 4 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                LogHelper.Info($"查询到设备配置信息 产线号={info.deviceName}");
                //瓶盖出库缓存位
                var workorder = WCSHelper.GetWorkOrder(info.deviceName);
                if (workorder != null)
                {
                    LogHelper.Info($"查询到执行中工单 工单号={workorder.S_WorkNo}");
                    var startinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 1 && a.ItemTrayType == "满").FirstOrDefault();
                    if (startinfo != null)
                    {
                        LogHelper.Info($"查询到缓存点配置信息 站点编码={startinfo.location}");
                        var startlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == startinfo.location).First();
                        if (startlocation != null)
                        {
                            LogHelper.Info($"该缓存点站点信息 当前数量={startlocation.N_CURRENT_NUM} 锁定状态={startlocation.S_LOCK_STATE.Trim()}");
                            if (startlocation.N_CURRENT_NUM == 2 && startlocation.S_LOCK_STATE.Trim() == "无")
                            {
                                Location endlocation = null;
                                //查找库里有没有三层的物料
                                for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                                {
                                    endlocation = pinggaiIn(startinfo.ProductArea[i], 3, true, workorder.S_BatchNo);
                                    if (endlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                        for (int j = 0; j < ctnslist.Count(); j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                        break;
                                    }
                                }
                            }
                            if (startlocation.N_CURRENT_NUM == 3 && startlocation.S_LOCK_STATE.Trim() == "无")
                            {
                                Location endlocation = null;
                                //查找库里有没有三层的物料
                                for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                                {
                                    endlocation = pinggaiIn(startinfo.ProductArea[i], 0, true, workorder.S_BatchNo);
                                    if (endlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                        for (int j = 0; j < ctnslist.Count(); j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                        break;
                                    }
                                }
                            }
                        }
                        else LogHelper.Info("缓存点站点表信息异常");
                    }
                    else LogHelper.Info("缓存点信息配置异常");
                }
                else LogHelper.Info("瓶盖满筐入库未找到工单");
            }
            else LogHelper.Info($"未找到设备配置文件");
        }

        /// <summary>
        /// 管控瓶盖入库缓存位
        /// </summary>
        private static void PingGaiIncontrel1()
        {
            var db = new SqlHelper<object>().GetInstance();
            //瓶盖入库不需要工单
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 2 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                //瓶盖出库缓存位
                var workorder = WCSHelper.GetWorkOrder(info.deviceName);
                if (workorder != null)
                {
                    var startinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 3 && a.ItemTrayType == "满").FirstOrDefault();
                    if (startinfo != null)
                    {
                        var startlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == startinfo.location).First();
                        if (startlocation != null)
                        {
                            if (startlocation.N_CURRENT_NUM == 2 && startlocation.S_LOCK_STATE.Trim() == "无")
                            {
                                Location endlocation = null;
                                //查找库里有没有三层的物料
                                for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                                {
                                    endlocation = pinggaiIn(startinfo.ProductArea[i], 3, true, workorder.S_BatchNo);
                                    if (endlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                        for (int j = 0; j < ctnslist.Count(); j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                        break;
                                    }
                                }
                            }
                            if (startlocation.N_CURRENT_NUM == 3 && startlocation.S_LOCK_STATE.Trim() == "无")
                            {
                                Location endlocation = null;
                                //查找库里有没有三层的物料
                                for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                                {
                                    endlocation = pinggaiIn(startinfo.ProductArea[i], 0, true, workorder.S_BatchNo);
                                    if (endlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                        for (int j = 0; j < ctnslist.Count(); j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }

            }
        }

        /// <summary>
        /// 管控瓶盖翻斗机入库缓存位
        /// </summary>
        private static void FanDouIncontrel()
        {
            var db = new SqlHelper<object>().GetInstance();
            //瓶盖翻斗机入库不需要工单
            var startinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 2 && a.ItemTrayType == "空").FirstOrDefault();
            if (startinfo != null)
            {
                LogHelper.Info($"查询到空筐入库区{startinfo.location} 库区编码={JsonConvert.SerializeObject(startinfo.ProductArea)}");
                var startlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == startinfo.location).First();
                if (startlocation != null)
                {
                    LogHelper.Info($"查询空筐入库区点位{startinfo.location} 当前数量={startlocation.N_CURRENT_NUM} 当前货位状态={startlocation.S_LOCK_STATE}");
                    if (startlocation.N_CURRENT_NUM == 2 && startlocation.S_LOCK_STATE.Trim() == "无")
                    {
                        Location endlocation = null;
                        //查找库里有没有三层的物料
                        for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                        {
                            endlocation = pinggaiIn(startinfo.ProductArea[i], 3);
                            if (endlocation != null)
                            {
                                var TrayCode = "";
                                var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                for (int j = 0; j < ctnslist.Count(); j++)
                                {
                                    TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                }
                                IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                break;
                            }
                        }
                    }
                    if (startlocation.N_CURRENT_NUM == 3 && startlocation.S_LOCK_STATE.Trim() == "无")
                    {
                        Location endlocation = null;
                        //查找库里有没有三层的物料
                        for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                        {
                            endlocation = pinggaiIn(startinfo.ProductArea[i], 0);
                            if (endlocation != null)
                            {
                                LogHelper.Info($"准备生成任务");
                                var TrayCode = "";
                                var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                for (int j = 0; j < ctnslist.Count(); j++)
                                {
                                    TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                }
                                LogHelper.Info($"生成空筐入库任务");
                                IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                break;
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 管控瓶盖翻斗机入库缓存位
        /// </summary>
        private static void FanDouIncontrel1()
        {
            var db = new SqlHelper<object>().GetInstance();
            //瓶盖翻斗机入库不需要工单
            var startinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 4 && a.ItemTrayType == "空").FirstOrDefault();
            if (startinfo != null)
            {
                LogHelper.Info($"查询到空筐入库区{startinfo.location} 库区编码={JsonConvert.SerializeObject(startinfo.ProductArea)}");
                var startlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == startinfo.location).First();
                if (startlocation != null)
                {
                    LogHelper.Info($"查询空筐入库区点位{startinfo.location} 当前数量={startlocation.N_CURRENT_NUM} 当前货位状态={startlocation.S_LOCK_STATE}");
                    if (startlocation.N_CURRENT_NUM == 2 && startlocation.S_LOCK_STATE.Trim() == "无")
                    {
                        Location endlocation = null;
                        //查找库里有没有三层的物料
                        for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                        {
                            endlocation = pinggaiIn(startinfo.ProductArea[i], 3);
                            if (endlocation != null)
                            {
                                var TrayCode = "";
                                var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                for (int j = 0; j < ctnslist.Count(); j++)
                                {
                                    TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                }
                                IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                break;
                            }
                        }
                    }
                    if (startlocation.N_CURRENT_NUM == 3 && startlocation.S_LOCK_STATE.Trim() == "无")
                    {
                        Location endlocation = null;
                        //查找库里有没有三层的物料
                        for (int i = 0; i < startinfo.ProductArea.Count(); i++)
                        {
                            endlocation = pinggaiIn(startinfo.ProductArea[i], 0);
                            if (endlocation != null)
                            {
                                LogHelper.Info($"准备生成任务");
                                var TrayCode = "";
                                var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                var endley = endlocation.N_CURRENT_NUM == 3 ? 2 : 1;
                                for (int j = 0; j < ctnslist.Count(); j++)
                                {
                                    TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                }
                                LogHelper.Info($"生成空筐入库任务");
                                IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐入库", TrayCode, 1, endley, "1", ctnslist.Count);
                                break;
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 瓶盖非即产即用 管控出库缓存区
        /// </summary>
        private static void PingGaiN()
        {
            try
            {
                LogHelper.Info("瓶盖出库管控");
                var db = new SqlHelper<object>().GetInstance();
                var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 4 && a.enable == 1).FirstOrDefault();
                if (info != null)
                {
                    //瓶盖出库缓存位
                    var workorder = WCSHelper.GetPGWorkOrder(info.deviceName);
                    //非即产即用工单对应 出库操作
                    if (workorder != null && workorder.S_WorkState.Trim() == "执行中" && workorder.S_UsingNow == "N")
                    {
                        //瓶盖机 非即产即用
                        var endinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 1 && a.ItemTrayType == "空").FirstOrDefault();
                        if (endinfo != null)
                        {
                            var endlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == endinfo.location).First();
                            if (endlocation.N_CURRENT_NUM == 0 && endlocation.S_LOCK_STATE == "无")
                            {
                                //终点满足条件 判断起点
                                for (int i = 0; i < endinfo.ProductArea.Count(); i++)
                                {
                                    var startlocation = pinggaiOut(endinfo.ProductArea[i]);
                                    if (startlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var count = ctnslist.Count() == 5 ? 2 : 3;
                                        var startley = ctnslist.Count() == 5 ? 2 : 1;
                                        for (int j = 0; j < count; j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐出库", TrayCode, startley, 1, "1");
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info($"瓶盖出库管控异常 异常信息={ex.Message}");
            }
        }

        /// <summary>
        /// 瓶盖非即产即用 管控出库缓存区
        /// </summary>
        private static void PingGaiN1()
        {
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 2 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                //瓶盖出库缓存位
                var workorder = WCSHelper.GetPGWorkOrder(info.deviceName);
                //非即产即用工单对应 出库操作
                if (workorder != null && workorder.S_WorkState.Trim() == "执行中" && workorder.S_UsingNow == "N")
                {
                    //瓶盖机 非即产即用
                    var endinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 3 && a.ItemTrayType == "空").FirstOrDefault();
                    if (endinfo != null)
                    {
                        var endlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == endinfo.location).First();
                        if (endlocation.N_CURRENT_NUM == 0 && endlocation.S_LOCK_STATE == "无")
                        {
                            //终点满足条件 判断起点
                            for (int i = 0; i < endinfo.ProductArea.Count(); i++)
                            {
                                var startlocation = pinggaiOut(endinfo.ProductArea[i]);
                                if (startlocation != null)
                                {
                                    var TrayCode = "";
                                    var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                    var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                    var count = ctnslist.Count() == 5 ? 2 : 3;
                                    var startley = ctnslist.Count() == 5 ? 2 : 1;
                                    for (int j = 0; j < count; j++)
                                    {
                                        TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                    }
                                    IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐出库", TrayCode, startley, 1, "1");
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 瓶盖翻斗非即产即用 管控出库缓存区
        /// </summary>
        private static void FanDouN()
        {
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 3 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                //瓶盖出库缓存位
                var workorder = WCSHelper.GetPGWorkOrder(info.deviceName);
                //非即产即用工单对应 出库操作
                if (workorder != null && workorder.S_WorkState.Trim() == "执行中" && workorder.S_UsingNow == "N")
                {
                    //瓶盖机 非即产即用
                    var endinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 2 && a.ItemTrayType == "满").FirstOrDefault();
                    if (endinfo != null)
                    {
                        var endlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == endinfo.location).First();
                        if (endlocation != null)
                        {
                            if (endlocation.N_CURRENT_NUM == 0 && endlocation.S_LOCK_STATE == "无")
                            {
                                //终点满足条件 判断起点
                                for (int i = 0; i < endinfo.ProductArea.Count(); i++)
                                {
                                    var startlocation = pinggaiOut(endinfo.ProductArea[i], true);
                                    if (startlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var count = ctnslist.Count() == 5 ? 2 : 3;
                                        var startley = ctnslist.Count() == 5 ? 2 : 1;
                                        for (int j = 0; j < count; j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐出库", TrayCode, startley, 1, "1");
                                        break;
                                    }
                                }
                            }
                        }

                    }
                }
            }
        }

        /// <summary>
        /// 瓶盖翻斗非即产即用 管控出库缓存区
        /// </summary>
        private static void FanDouN1()
        {
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 6 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                //瓶盖出库缓存位
                var workorder = WCSHelper.GetPGWorkOrder(info.deviceName);
                //非即产即用工单对应 出库操作
                if (workorder != null && workorder.S_WorkState.Trim() == "执行中" && workorder.S_UsingNow == "N")
                {
                    //瓶盖机 非即产即用
                    var endinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 4 && a.ItemTrayType == "满").FirstOrDefault();
                    if (endinfo != null)
                    {
                        var endlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == endinfo.location).First();
                        if (endlocation != null)
                        {
                            if (endlocation.N_CURRENT_NUM == 0 && endlocation.S_LOCK_STATE == "无")
                            {
                                //终点满足条件 判断起点
                                for (int i = 0; i < endinfo.ProductArea.Count(); i++)
                                {
                                    var startlocation = pinggaiOut(endinfo.ProductArea[i], true);
                                    if (startlocation != null)
                                    {
                                        var TrayCode = "";
                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                        var ctnslist = ctnsinfo.OrderByDescending(a => a.T_CREATE).ToList();
                                        var count = ctnslist.Count() == 5 ? 2 : 3;
                                        var startley = ctnslist.Count() == 5 ? 2 : 1;
                                        for (int j = 0; j < count; j++)
                                        {
                                            TrayCode = TrayCode + ctnslist[j].S_CNTR_CODE + ",";
                                        }
                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐出库", TrayCode, startley, 1, "1");
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 瓶盖空筐-出库缓存区的连接
        /// </summary>
        private static void PingGaikkcontrel()
        {
            LogHelper.Info("瓶盖空筐区管控");
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 4 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                //出库缓存区对应缓存区 缓存区如果有空位置就从出库缓存区搬运
                LogHelper.Info($"查询空筐区是否有空货位");
                var Areainfo = Settings.GetDaMingShanPriProLineList().Where(a => a.deviceName == info.deviceName && a.ItemTrayType == "空").FirstOrDefault();
                if (Areainfo != null)
                {
                    LogHelper.Info($"查询空筐缓存位 库区编码={Areainfo.ProductArea[0]}");
                    string msg = Areainfo.ProductArea[0];
                    var endlocation = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == msg && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE.Trim() == "无").First();
                    if (endlocation != null)
                    {
                        LogHelper.Info($"查询到空筐区空货位 货位编码={endlocation.S_LOC_CODE}");
                        var locationinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 1 && a.ItemTrayType == "空").FirstOrDefault();
                        if (locationinfo != null)
                        {
                            LogHelper.Info($"查询出库缓存位是否有货 货位编码={locationinfo.location}");
                            var startlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locationinfo.location).First();
                            if (startlocation.S_LOCK_STATE.Trim() == "无" && startlocation.N_CURRENT_NUM > 0)
                            {
                                LogHelper.Info($"查询到出库缓存位 货位编码={startlocation} 数量={startlocation.N_CURRENT_NUM}");
                                var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                if (ctnsinfo.Count() > 0)
                                {
                                    var ctns = ctnsinfo.OrderByDescending(a => a.T_CREATE).First();
                                    LogHelper.Info($"创建空筐缓存区补空任务 托盘号={ctns.S_CNTR_CODE}");
                                    IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐入缓存区", ctns.S_CNTR_CODE, startlocation.N_CURRENT_NUM, 1, "1");
                                }
                            }
                        }
                        else LogHelper.Info($"瓶盖出库缓存区配置未配置");
                    }
                    else LogHelper.Info($"空筐缓存区未找到空货位");
                }
                else LogHelper.Info($"空筐缓存区未配置");
            }
        }

        /// <summary>
        /// 瓶坯空筐-出库缓存区的连接
        /// </summary>
        private static void PingGaikkcontrel1()
        {
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 2 && a.enable == 1).ToList();
            if (info.Count() > 0)
            {
                info.ForEach(b =>
                {
                    var workorder = WCSHelper.GetPGWorkOrder(b.deviceName);
                    if (workorder != null)
                    {
                        //出库缓存区对应缓存区 缓存区如果有空位置就从出库缓存区搬运
                        LogHelper.Info($"查询空筐区是否有空货位");
                        var Areainfo = Settings.GetDaMingShanPriProLineList().Where(a => a.deviceName == workorder.S_LinkLineNo && a.ItemTrayType == "空").FirstOrDefault();
                        if (Areainfo != null)
                        {
                            if (Areainfo.ProductArea.Count() > 0)
                            {
                                for (int i = 0; i < Areainfo.ProductArea.Count(); i++)
                                {
                                    LogHelper.Info($"查询空筐缓存位 库区编码={Areainfo.ProductArea[i]}");
                                    string msg = Areainfo.ProductArea[i];
                                    var endlocation = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == msg && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE.Trim() == "无").First();
                                    if (endlocation != null)
                                    {
                                        LogHelper.Info($"查询到空筐区空货位 货位编码={endlocation.S_LOC_CODE}");
                                        var locationinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 3 && a.ItemTrayType == "空").FirstOrDefault();
                                        if (locationinfo != null)
                                        {
                                            LogHelper.Info($"查询出库缓存位是否有货 货位编码={locationinfo.location}");
                                            var startarea = db.Queryable<Location>().Where(a => a.S_AREA_CODE == locationinfo.location).ToList();
                                            foreach (var item in startarea)
                                            {
                                                var startlocation = item;
                                                if (startlocation.S_LOCK_STATE.Trim() == "无" && startlocation.N_CURRENT_NUM > 0)
                                                {
                                                    LogHelper.Info($"查询到出库缓存位 货位编码={startlocation} 数量={startlocation.N_CURRENT_NUM}");
                                                    var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                                    if (ctnsinfo.Count() > 0)
                                                    {
                                                        var ctns = ctnsinfo.OrderByDescending(a => a.T_CREATE).First();
                                                        LogHelper.Info($"创建空筐缓存区补空任务 托盘号={ctns.S_CNTR_CODE}");
                                                        IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "空筐入缓存区", ctns.S_CNTR_CODE, startlocation.N_CURRENT_NUM, 1, "1");
                                                        break;
                                                    }
                                                }
                                            }
                                        }
                                        else LogHelper.Info($"瓶坯出库缓存区配置未配置");
                                    }
                                    else LogHelper.Info($"空筐缓存区未找到空货位");
                                }

                            }
                            else LogHelper.Info("请检查空筐缓存区库区编号是否配置");
                        }
                        else LogHelper.Info($"空筐缓存区未配置");
                    }

                });
            }
        }

        /// <summary>
        /// 翻斗满筐-出库缓存区的连接
        /// </summary>
        private static void FanDoukkcontrel()
        {
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 3 && a.enable == 1).FirstOrDefault();
            if (info != null)
            {
                //出库缓存区对应缓存区 缓存区如果有空位置就从出库缓存区搬运
                LogHelper.Info($"查询满筐区是否有空货位");
                var Areainfo = Settings.GetDaMingShanPriProLineList().Where(a => a.deviceName == info.deviceName && a.ItemTrayType == "满").FirstOrDefault();
                if (Areainfo != null)
                {
                    LogHelper.Info($"查询满筐缓存位 库区编码={Areainfo.ProductArea[0]}");
                    string msg = Areainfo.ProductArea[0];
                    var endlocation = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == msg && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE.Trim() == "无").First();
                    if (endlocation != null)
                    {
                        LogHelper.Info($"查询到满筐区空货位 货位编码={endlocation.S_LOC_CODE}");
                        var locationinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 2 && a.ItemTrayType == "满").FirstOrDefault();
                        if (locationinfo != null)
                        {
                            LogHelper.Info($"查询出库缓存位是否有货 货位编码={locationinfo.location}");
                            var startlocation = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locationinfo.location).First();
                            if (startlocation.S_LOCK_STATE.Trim() == "无" && startlocation.N_CURRENT_NUM > 0)
                            {
                                LogHelper.Info($"查询到出库缓存位 货位编码={startlocation} 数量={startlocation.N_CURRENT_NUM}");
                                var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                if (ctnsinfo.Count() > 0)
                                {
                                    var ctns = ctnsinfo.OrderByDescending(a => a.T_CREATE).First();
                                    LogHelper.Info($"创建满筐缓存区补满任务 托盘号={ctns.S_CNTR_CODE}");
                                    IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入缓存区", ctns.S_CNTR_CODE, startlocation.N_CURRENT_NUM, 1, "1");
                                }
                            }
                        }
                        else LogHelper.Info($"瓶盖翻斗机出库缓存区配置未配置");
                    }
                    else LogHelper.Info($"满筐缓存区未找到空货位");
                }
                else LogHelper.Info($"满筐缓存区未配置");
            }
        }

        /// <summary>
        /// 翻斗满筐-出库缓存区的连接
        /// </summary>
        private static void FanDoukkcontrel1()
        {
            var db = new SqlHelper<object>().GetInstance();
            var info = Settings.GetDeviceInfoList().Where(a => a.deviceType == 6 && a.enable == 1).ToList();
            if (info.Count() > 0)
            {
                info.ForEach(b =>
                {
                    #region 更新前同瓶盖
                    var workorder = WCSHelper.GetPGWorkOrder(b.deviceName);
                    if (workorder != null)
                    {
                        //出库缓存区对应缓存区 缓存区如果有空位置就从出库缓存区搬运
                        LogHelper.Info($"查询满筐区是否有空货位");
                        var Areainfo = Settings.GetDaMingShanPriProLineList().Where(a => a.deviceName == workorder.S_LinkLineNo && a.ItemTrayType == "满").FirstOrDefault();
                        if (Areainfo != null)
                        {
                            if (Areainfo.ProductArea.Count() > 0)
                            {
                                for (int i = 0; i < Areainfo.ProductArea.Count(); i++)
                                {
                                    LogHelper.Info($"查询满筐缓存位 库区编码={Areainfo.ProductArea[i]}");
                                    string msg = Areainfo.ProductArea[i];
                                    var endlocation = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == msg && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE.Trim() == "无").First();
                                    if (endlocation != null)
                                    {
                                        LogHelper.Info($"查询到满筐区空货位 货位编码={endlocation.S_LOC_CODE}");
                                        var locationinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 4 && a.ItemTrayType == "满").FirstOrDefault();
                                        if (locationinfo != null)
                                        {
                                            LogHelper.Info($"查询出库缓存位是否有货 货位编码={locationinfo.location}");
                                            var startarea = db.Queryable<Location>().Where(a => a.S_AREA_CODE == locationinfo.location).Includes(a => a.LocCntrRel, a => a.CntrItemRel).ToList();
                                            foreach (var item in startarea)
                                            {
                                                var startlocation = item;
                                                if (startlocation.S_LOCK_STATE.Trim() == "无" && startlocation.N_CURRENT_NUM > 0)
                                                {
                                                    LogHelper.Info($"查询到出库缓存位 货位编码={startlocation} 数量={startlocation.N_CURRENT_NUM} 物料编码={startlocation.LocCntrRel.CntrItemRel.S_ITEM_CODE}");
                                                    if (workorder.S_ItemCode == startlocation.LocCntrRel.CntrItemRel.S_ITEM_CODE)
                                                    {
                                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                                                        if (ctnsinfo.Count() > 0)
                                                        {
                                                            var ctns = ctnsinfo.OrderByDescending(a => a.T_CREATE).First();
                                                            LogHelper.Info($"创建满筐缓存区补满任务 托盘号={ctns.S_CNTR_CODE}");
                                                            IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入缓存区", ctns.S_CNTR_CODE, startlocation.N_CURRENT_NUM, 1, "1");
                                                            break;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        else LogHelper.Info($"瓶盖翻斗机出库缓存区配置未配置");
                                    }
                                    else LogHelper.Info($"满筐缓存区未找到空货位");
                                }
                            }
                            else LogHelper.Info($"库区编码异常请检查配置");
                        }
                        else LogHelper.Info($"满筐缓存区未配置");
                    }
                    #endregion

                    #region 更新后
                    //var workorder = WCSHelper.GetWorkOrder1(b.deviceName);
                    //if (workorder.Count>0)
                    //{
                    //    foreach (var work in workorder)
                    //    {
                    //        //出库缓存区对应缓存区 缓存区如果有空位置就从出库缓存区搬运
                    //        LogHelper.Info($"查询满筐区是否有空货位");
                    //        var Areainfo = Settings.GetDaMingShanPriProLineList().Where(a => a.deviceName == work.S_LinkLineNO && a.ItemTrayType == "满").FirstOrDefault();
                    //        if (Areainfo != null)
                    //        {
                    //            if (Areainfo.ProductArea.Count() > 0)
                    //            {
                    //                for (int i = 0; i < Areainfo.ProductArea.Count(); i++)
                    //                {
                    //                    LogHelper.Info($"查询满筐缓存位 库区编码={Areainfo.ProductArea[i]}");
                    //                    string msg = Areainfo.ProductArea[i];
                    //                    var endlocation = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == msg && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE.Trim() == "无").First();
                    //                    if (endlocation != null)
                    //                    {
                    //                        LogHelper.Info($"查询到满筐区空货位 货位编码={endlocation.S_LOC_CODE}");
                    //                        var locationinfo = Settings.GetinStockCacheBitList().Where(a => a.deviceType == 4 && a.ItemTrayType == "满").FirstOrDefault();
                    //                        if (locationinfo != null)
                    //                        {
                    //                            LogHelper.Info($"查询出库缓存位是否有货 货位编码={locationinfo.location}");
                    //                            var startarea = db.Queryable<Location>().Where(a => a.S_AREA_CODE == locationinfo.location).Includes(a => a.LocCntrRel, a => a.CntrItemRel).ToList();
                    //                            foreach (var item in startarea)
                    //                            {
                    //                                var startlocation = item;
                    //                                if (startlocation.S_LOCK_STATE.Trim() == "无" && startlocation.N_CURRENT_NUM > 0)
                    //                                {
                    //                                    LogHelper.Info($"查询到出库缓存位 货位编码={startlocation} 数量={startlocation.N_CURRENT_NUM} 物料编码={startlocation.LocCntrRel.CntrItemRel.S_ITEM_CODE}");
                    //                                    if (work.S_ItemCode == startlocation.LocCntrRel.CntrItemRel.S_ITEM_CODE)
                    //                                    {
                    //                                        var ctnsinfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startlocation.S_LOC_CODE.Trim()).ToList();
                    //                                        if (ctnsinfo.Count() > 0)
                    //                                        {
                    //                                            var ctns = ctnsinfo.OrderByDescending(a => a.T_CREATE).First();
                    //                                            LogHelper.Info($"创建满筐缓存区补满任务 托盘号={ctns.S_CNTR_CODE}");
                    //                                            IntensiveArea.DaMingShanCreateTransport(startlocation.S_LOC_CODE, endlocation.S_LOC_CODE, "满筐入缓存区", ctns.S_CNTR_CODE, startlocation.N_CURRENT_NUM, 1, "1");
                    //                                            break;
                    //                                        }
                    //                                    }
                    //                                }
                    //                            }
                    //                        }
                    //                        else LogHelper.Info($"瓶盖翻斗机出库缓存区配置未配置");
                    //                    }
                    //                    else LogHelper.Info($"满筐缓存区未找到空货位");
                    //                }
                    //            }
                    //            else LogHelper.Info($"库区编码异常请检查配置");
                    //        }
                    //        else LogHelper.Info($"满筐缓存区未配置");
                    //    }
                    //
                    //}
                    #endregion

                });
            }
        }

        private static Location pinggaiIn(string area, int i, bool batchbol = false, string batch = "")
        {
            LogHelper.Info($"瓶盖入库算法开始 数量={i} 库区编码={area} 批次号={batch}");
            Location endlocation = null;
            var db = new SqlHelper<object>().GetInstance();


            if (i == 3)
            {
                LogHelper.Info("查找二层货位");
                var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM == i && a.S_AREA_CODE == area).OrderBy(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
                for (int j = list.Count() - 1; j >= 0; j--)
                {
                    string rowno = list[j].N_ROW;
                    var rowinfo = db.Queryable<Location>().Where(a => a.N_ROW == rowno && a.S_LOCK_STATE != "无").First();
                    if (rowinfo != null)
                    {
                        list.Remove(list[j]);
                    }
                    else
                    {
                        if (batchbol)
                        {
                            var batchinfo = db.Queryable<Location>().Where(a => a.N_ROW == rowno && a.N_CURRENT_NUM > 0).Includes(a => a.LocCntrRel, a => a.CntrItemRel).First();
                            if (batchinfo != null)
                            {
                                LogHelper.Info($"物料批次={batchinfo.LocCntrRel.CntrItemRel.S_BATCH_NO}");
                                if (batchinfo.LocCntrRel.CntrItemRel.S_BATCH_NO.Trim() != batch.Trim())
                                {
                                    list.Remove(list[j]);
                                }
                            }
                        }
                    }
                }
                if (list.Count() > 0)
                {
                    for (int k = 0; k < list.Count; k++)
                    {
                        if (list[k].N_CURRENT_NUM == i)
                        {
                            endlocation = list[k];
                            break;
                        }
                    }
                }
            }
            else
            {
                LogHelper.Info("查找一层货位");
                var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM == i && a.S_AREA_CODE == area).OrderBy(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
                LogHelper.Info($"查找满足数量的货位 货位数量为{list.Count()}");
                for (int j = list.Count() - 1; j >= 0; j--)
                {
                    string rowno = list[j].N_ROW;
                    LogHelper.Info($"查找排{rowno} 货位状态");
                    var rowinfo = db.Queryable<Location>().Where(a => a.N_ROW == rowno && a.S_LOCK_STATE != "无").First();
                    if (rowinfo != null)
                    {
                        LogHelper.Info($"排{rowno}状态{rowinfo.S_LOCK_STATE} 剔除该排");
                        list.Remove(list[j]);
                    }
                    else
                    {
                        if (batchbol)
                        {
                            LogHelper.Info($"开启批次比对");
                            var batchinfo = db.Queryable<Location>().Where(a => a.N_ROW == rowno && a.N_CURRENT_NUM > 0).Includes(a => a.LocCntrRel, a => a.CntrItemRel).First();
                            if (batchinfo != null)
                            {
                                LogHelper.Info($"物料批次={batchinfo.LocCntrRel.CntrItemRel.S_BATCH_NO}");
                                if (batchinfo.LocCntrRel.CntrItemRel.S_BATCH_NO.Trim() != batch.Trim())
                                {
                                    list.Remove(list[j]);
                                }
                            }
                            else
                            {
                                LogHelper.Info($"排号{rowno} 为空排");
                            }
                        }
                    }
                }
                if (list.Count() > 0)
                {
                    for (int k = 0; k < list.Count(); k++)
                    {
                        LogHelper.Info($"开始判断货位是否为最小列 货位编码={list[k].S_LOC_CODE} 列={list[k].N_COL}");
                        if (list[k].N_COL == 1)
                        {
                            endlocation = list[k];
                            break;
                        }
                        else
                        {
                            //查找前一列货位是否为满
                            string Rowno = list[k].N_ROW;
                            int colno = list[k].N_COL - 1;
                            var info = db.Queryable<Location>().Where(a => a.N_ROW == Rowno && a.N_COL == colno).First();
                            if (info != null)
                            {
                                if (info.N_CAPACITY == info.N_CURRENT_NUM)
                                {
                                    endlocation = list[k];
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            LogHelper.Info($"瓶盖区入库算法结束 终点货位结果 {endlocation != null}");
            return endlocation;
        }

        private static Location pinggaiOut(string area, bool res = false)
        {
            Location location = null;
            var db = new SqlHelper<object>().GetInstance();
            var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).Includes(a => a.LocCntrRel, a => a.CntrItemRel).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
            for (int j = list.Count - 1; j >= 0; j--)
            {
                var rowno = list[j].N_ROW;
                var rowinfo = db.Queryable<Location>().Where(a => a.N_ROW == rowno && a.S_LOCK_STATE != "无").First();
                if (rowinfo != null)
                {
                    list.Remove(list[j]);
                }
            }
            if (list.Count() > 0)
            {
                if (res)
                {
                    list = list.OrderBy(a => a.LocCntrRel.CntrItemRel.S_BATCH_NO).ToList();
                }
                location = list[0];
            }
            return location;
        }


        /// <summary>
        /// 人工移库
        /// </summary>
        public static void AnalysisIntraoCular()
        {
            var WorkInfo = WCSHelper.GetDaMingShanAnalysisOrderWork("人工移库");
            if (WorkInfo != null)
            {
                AnalysisCularAndStock(WorkInfo);
            }
        }




        /// <summary>
        /// 人工移库
        /// </summary>
        /// <param name="WorkInfo">工单信息</param>
        /// <param name="Analysis">工单处理类型： true-人工-备货-管制处理  false-缠膜处理</param>
        private static void AnalysisCularAndStock(List<WorkOrder> WorkInfo, bool Analysis = true)
        {
            var db = new SqlHelper<object>().GetInstance();//ChunAnAnalysisMoveLib
            WorkInfo.ForEach(it =>
            {
                LogHelper.Info($"移库任务处理：工单号：{it.S_WorkNo.Trim()}，工单类型：{it.S_ORDER_TYPE.Trim()}", "Monitor");
                //Console.WriteLine($"移库任务处理：工单号：{it.S_WorkNo.Trim()}，工单类型：{it.S_ORDER_TYPE.Trim()}");
                //起点库区 终点库区 起点库位 终点库位
                //人工下工单  起点库位 可能存在多个，用英文逗号隔开；终点库位 同 起点库位
                //作为 起点库位 如果为空，解锁库位，且不在作为起点库位使用；终点库位 满 则不在转运
                // SQL_StartArea S_StartLoca SQL_EndArea S_EndLoca 
                string startNo = ""; string endNo = ""; string startArea = ""; string endArea = "";
                string ItemCode = string.IsNullOrEmpty(it.S_ItemCode) ? "" : it.S_ItemCode.Trim();
                string BatchNo = string.IsNullOrEmpty(it.S_BatchNo) ? "" : it.S_BatchNo.Trim();
                string ItemLayer = string.IsNullOrEmpty(it.S_ItemLayer) ? "" : it.S_ItemLayer.Trim();
                List<string> startList = it.S_StartLoca.Trim().Split(',').ToList();
                List<string> endList = it.S_EndLoca.Trim().Split(',').ToList();
                if (it.S_YiKuNum > 0)
                {
                    startList.ForEach(a =>
                    {
                        if (!string.IsNullOrEmpty(a))
                        {
                            var startlocationlist = db.Queryable<Location>().Where(info => info.N_ROW.Trim() == a && info.S_LOCK_STATE.Trim() != "无" && info.S_LOCK_STATE.Trim() != "报废").ToList();
                            if (startlocationlist.Count() == 0)
                            {
                                //查询有锁的库位 如果没有：锁定所有出库货位
                                var liststart = db.Queryable<Location>().Where(b => b.N_ROW.Trim() == a).ToList();
                                foreach (var item in liststart)
                                {
                                    if (item.S_LOCK_STATE.Trim() != "报废")
                                    {
                                        item.S_LOCK_STATE = "移库锁";
                                        db.Updateable(item).UpdateColumns(ab => new { ab.S_LOCK_STATE }).ExecuteCommand();
                                    }
                                }
                                TaskProcess.AreaRowLockState(a);
                            }
                            //查询到 可出库的 起点库位，判断当前起点库位是否允许生成任务
                            //任务类型  库区编码+排号+移库类型------起点库位 任务 均取货完成

                            //正式环境 排号为STRING型，唯一，人工无需传输库区编码
                            //var startAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == int.Parse(a)).OrderBy(b => b.N_COL).Take(1).First();

                            //测试环境 排号为INT型，存在重复排号，因此加上 库区编码 用作区分
                            var yikulock = db.Queryable<Location>().Where(start => start.N_ROW.Trim() == a && start.S_LOCK_STATE.Trim() == "移库锁").First();
                            if (yikulock != null)
                            {
                                var startAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == a && b.N_CURRENT_NUM > 0).OrderByDescending(b => b.N_COL).Take(1).First();
                                if (startAreaInfo != null && startAreaInfo.N_CURRENT_NUM >= 1)
                                {
                                    //YiKuUnLockRow(db, a, startAreaInfo.S_AREA_CODE.Trim(), false);
                                    //判断当前库位是否可用    根据库区获取此库区 所有执行中的任务
                                    //如果 有执行中的 任务，且未取货完成，则不可用；反之，无执行中任务 或 任务已取货完成 即可使用
                                    if (IntensiveArea.TaskTakeAreaOver(startAreaInfo.S_AREA_CODE.Trim(), a, true, Analysis))
                                    {
                                        startNo = a;
                                        startArea = startAreaInfo.S_AREA_CODE.Trim();
                                    }
                                }
                            }
                        }
                    });
                    if (!string.IsNullOrEmpty(startNo))
                    {
                        endList.ForEach(a =>
                        {
                            if (!string.IsNullOrEmpty(a))
                            {
                                if (ItemBool(startNo, a))
                                {
                                    var startlocationlist = db.Queryable<Location>().Where(info => info.N_ROW.Trim() == a && info.S_LOCK_STATE.Trim() != "无" && info.S_LOCK_STATE.Trim() != "报废").ToList();
                                    if (startlocationlist.Count() == 0)
                                    {
                                        //查询有锁的库位 如果没有：锁定所有出库货位
                                        var liststart = db.Queryable<Location>().Where(b => b.N_ROW.Trim() == a).ToList();
                                        foreach (var item in liststart)
                                        {
                                            if (item.S_LOCK_STATE.Trim() != "报废")
                                            {
                                                item.S_LOCK_STATE = "移库锁";
                                                db.Updateable(item).UpdateColumns(ab => new { ab.S_LOCK_STATE }).ExecuteCommand();
                                            }
                                        }
                                        TaskProcess.AreaRowLockState(a);
                                    }
                                    //获取可用的 终点库位 ：1.终点库位 不能有任务执行中  2.根据终点库区 查询 出所有属于此 库位的任务
                                    var endAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == a && b.N_CURRENT_NUM < b.N_CAPACITY).PartitionBy(b => b.S_AREA_CODE).OrderByDescending(b => b.N_COL).Take(1).ToList();
                                    foreach (var item in endAreaInfo)
                                    {
                                        if (item != null && item.N_CURRENT_NUM < item.N_CAPACITY)
                                        {
                                            var StartCntrType = db.Queryable<ItemArea>().Where(b => b.S_AREA_CODE == startArea).First();
                                            var EndCntrType = db.Queryable<ItemArea>().Where(b => b.S_AREA_CODE == item.S_AREA_CODE).First();
                                            LogHelper.Info($"起点库区{startArea} 排{startNo} 板型={StartCntrType.S_TRAY_TYPE}");
                                            LogHelper.Info($"终点库区{item.S_AREA_CODE.Trim()} 排{a} 板型={EndCntrType.S_TRAY_TYPE}");

                                            if (StartCntrType.S_TRAY_TYPE == EndCntrType.S_TRAY_TYPE)
                                            {
                                                LogHelper.Info($"板型匹配");
                                                //YiKuUnLockRow(db, a, endAreaInfo.S_AREA_CODE.Trim(), false);
                                                if (IntensiveArea.TaskTakeAreaOver(item.S_AREA_CODE.Trim(), a, false))
                                                {
                                                    endNo = a;
                                                    endArea = item.S_AREA_CODE.Trim();
                                                    break;
                                                }
                                            }
                                            else
                                            {
                                                LogHelper.Info($"板型不匹配");
                                            }
                                        }
                                    }
                                }
                            }
                        });

                    }
                    if (Analysis)
                    {
                        if (!string.IsNullOrEmpty(startNo) && !string.IsNullOrEmpty(endNo))
                        {
                            //string taskType = it.S_ORDER_TYPE.Trim() + ":" + startNo + "-" + endNo;
                            IntensiveArea.DaMingShanYiKuTask(startArea, endArea, startNo, endNo, "成品移库", ItemCode, BatchNo, ItemLayer, it.S_WorkNo.Trim());
                        }
                    }
                }

                //解锁并完成工单
                CompleteAndUnLockWork(it, db, startList, endList);
            });
        }



        private static bool ItemBool(string startRow, string endRow)
        {
            var result = false;
            var db = new SqlHelper<object>().GetInstance();
            var startitem = db.Queryable<Location>().Where(a => a.N_ROW == startRow && a.N_CURRENT_NUM > 0).First();
            var enditem = db.Queryable<Location>().Where(a => a.N_ROW == endRow && a.N_CURRENT_NUM > 0).First();

            if (enditem == null)
            {
                return true;
            }
            if (startitem != null && enditem != null)
            {
                var starttray = db.Queryable<ItemArea>().Where(a => a.S_AREA_CODE == startitem.S_AREA_CODE).First();
                var endtray = db.Queryable<ItemArea>().Where(a => a.S_AREA_CODE == enditem.S_AREA_CODE).First();

                if (starttray.S_TRAY_TYPE == endtray.S_TRAY_TYPE)
                {
                    result = true;
                }
                else
                {
                    LogHelper.Info($"起点排{startRow} 货位{startitem.S_LOC_CODE} 与 终点排{endRow} 货位{enditem.S_LOC_CODE} 板型不符");
                }
            }
            else
            {
                LogHelper.Info($"起点排{startRow} 查询不到当前数量不为0的货位");
            }
            return result;
        }

        /// <summary>
        /// 备货移库
        /// </summary>
        /// <param name="WorkInfo"></param>
        /// <param name="Analysis"></param>
        private static void AnalysisCularAndStock1(List<WorkOrder> WorkInfo, bool Analysis = true)
        {
            var db = new SqlHelper<object>().GetInstance();//ChunAnAnalysisMoveLib
            WorkInfo.ForEach(it =>
            {
                LogHelper.Info($"移库任务处理：工单号：{it.S_WorkNo.Trim()}，工单类型：{it.S_ORDER_TYPE.Trim()}", "Monitor");
                //Console.WriteLine($"移库任务处理：工单号：{it.S_WorkNo.Trim()}，工单类型：{it.S_ORDER_TYPE.Trim()}");
                //起点库区 终点库区 起点库位 终点库位
                //人工下工单  起点库位 可能存在多个，用英文逗号隔开；终点库位 同 起点库位
                //作为 起点库位 如果为空，解锁库位，且不在作为起点库位使用；终点库位 满 则不在转运
                // SQL_StartArea S_StartLoca SQL_EndArea S_EndLoca 
                string startNo = ""; string endNo = ""; string startArea = ""; string endArea = "";
                List<string> startList = new List<string>(it.S_StartLoca.Trim().Split(','));
                List<string> endList = new List<string>(it.S_EndLoca.Trim().Split(','));
                if (it.S_YiKuNum > 0)
                {
                    startList.ForEach(a =>
                    {
                        if (!string.IsNullOrEmpty(a))
                        {
                            var startlocationlist = db.Queryable<Location>().Where(info => info.N_ROW.Trim() == a && info.S_LOCK_STATE.Trim() != "无" && info.S_LOCK_STATE.Trim() != "报废").ToList();
                            if (startlocationlist.Count() == 0)
                            {
                                //查询有锁的库位 如果没有：锁定所有出库货位
                                var liststart = db.Queryable<Location>().Where(b => b.N_ROW.Trim() == a).ToList();
                                foreach (var item in liststart)
                                {
                                    if (item.N_CURRENT_NUM > 0 && item.S_LOCK_STATE.Trim() != "报废")
                                    {
                                        item.S_LOCK_STATE = "移库锁";
                                        db.Updateable(item).UpdateColumns(ab => new { ab.S_LOCK_STATE }).ExecuteCommand();
                                    }
                                }
                                TaskProcess.AreaRowLockState(a);
                            }
                            //查询到 可出库的 起点库位，判断当前起点库位是否允许生成任务
                            //任务类型  库区编码+排号+移库类型------起点库位 任务 均取货完成

                            //正式环境 排号为STRING型，唯一，人工无需传输库区编码
                            //var startAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == int.Parse(a)).OrderBy(b => b.N_COL).Take(1).First();

                            //测试环境 排号为INT型，存在重复排号，因此加上 库区编码 用作区分
                            var yikulock = db.Queryable<Location>().Where(start => start.N_ROW.Trim() == a && start.S_LOCK_STATE.Trim() == "移库锁").First();
                            if (yikulock != null)
                            {
                                var startAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == a && b.N_CURRENT_NUM > 0).OrderByDescending(b => b.N_COL).Take(1).First();
                                if (startAreaInfo != null && startAreaInfo.N_CURRENT_NUM >= 1)
                                {
                                    //YiKuUnLockRow(db, a, startAreaInfo.S_AREA_CODE.Trim(), false);
                                    //判断当前库位是否可用    根据库区获取此库区 所有执行中的任务
                                    //如果 有执行中的 任务，且未取货完成，则不可用；反之，无执行中任务 或 任务已取货完成 即可使用
                                    if (IntensiveArea.TaskTakeAreaOver(startAreaInfo.S_AREA_CODE.Trim(), a, true, Analysis))
                                    {
                                        startNo = a;
                                        startArea = startAreaInfo.S_AREA_CODE.Trim();
                                    }
                                }
                            }
                        }
                    });
                    if (!string.IsNullOrEmpty(startNo))
                    {
                        endList.ForEach(a =>
                        {
                            if (!string.IsNullOrEmpty(a))
                            {
                                var startlocationlist = db.Queryable<Location>().Where(info => info.N_ROW.Trim() == a && info.S_LOCK_STATE.Trim() != "无" && info.S_LOCK_STATE.Trim() != "报废").ToList();
                                if (startlocationlist.Count() == 0)
                                {
                                    //查询有锁的库位 如果没有：锁定所有出库货位
                                    var liststart = db.Queryable<Location>().Where(b => b.N_ROW.Trim() == a).ToList();
                                    foreach (var item in liststart)
                                    {
                                        if (item.N_CURRENT_NUM < 2 && item.S_LOCK_STATE.Trim() != "报废")
                                        {
                                            item.S_LOCK_STATE = "移库锁";
                                            db.Updateable(item).UpdateColumns(ab => new { ab.S_LOCK_STATE }).ExecuteCommand();
                                        }
                                    }
                                    TaskProcess.AreaRowLockState(a);
                                }
                                //获取可用的 终点库位 ：1.终点库位 不能有任务执行中  2.根据终点库区 查询 出所有属于此 库位的任务
                                var endAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == a && b.N_CURRENT_NUM < b.N_CAPACITY).OrderByDescending(b => b.N_COL).Take(1).First();
                                if (endAreaInfo != null && endAreaInfo.N_CURRENT_NUM < endAreaInfo.N_CAPACITY)
                                {
                                    //YiKuUnLockRow(db, a, endAreaInfo.S_AREA_CODE.Trim(), false);
                                    if (IntensiveArea.TaskTakeAreaOver(endAreaInfo.S_AREA_CODE.Trim(), a, false))
                                    {
                                        endNo = a;
                                        endArea = endAreaInfo.S_AREA_CODE.Trim();
                                    }
                                }
                            }
                        });
                    }
                    if (Analysis)
                    {
                        if (!string.IsNullOrEmpty(startNo) && !string.IsNullOrEmpty(endNo))
                        {
                            //string taskType = it.S_ORDER_TYPE.Trim() + ":" + startNo + "-" + endNo;
                            IntensiveArea.DaMingShanYiKuTask1(startArea, endArea, startNo, endNo, it.S_ORDER_TYPE.Trim(), it.S_WorkNo.Trim());
                        }
                    }
                }

                //解锁并完成工单
                CompleteAndUnLockWork(it, db, startList, endList);
            });
        }

        /// <summary>
        /// 解锁并完成工单
        /// </summary>
        /// <param name="it"></param>
        /// <param name="db"></param>
        /// <param name="startList"></param>
        /// <param name="endList"></param>
        private static void CompleteAndUnLockWork(WorkOrder it, SqlSugar.SqlSugarClient db, List<string> startList, List<string> endList)
        {
            //查询到起点库位全部移库完毕，解锁全部库位，并更改工单状态为 移库完成
            //9999-整排移库--需判断起点排均移库完毕，完成工单
            //其他：移库数量为0，即可完成工单
            bool result = true;
            if (it.S_YiKuNum == 9999)
            {
                startList.ForEach(a =>
                {
                    if (!string.IsNullOrEmpty(a))
                    {
                        //var startAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == int.Parse(a)).OrderBy(b => b.N_COL).Take(1).First();

                        var startAreaInfo = db.Queryable<Location>().Where(b => b.N_ROW == a && b.N_CURRENT_NUM > 0).OrderBy(b => b.N_COL).Take(1).First();
                        if (startAreaInfo != null) result = false;
                    }
                });
            }
            else if (it.S_YiKuNum != 0 && it.S_YiKuNum > 0) result = false;
            else
            {
                LogHelper.Info($"移库工单异常：工单号：{it.S_WorkNo.Trim()},工单类型：{it.S_ORDER_TYPE.Trim()}，移库数量：{it.S_YiKuNum}", "Monitor");
                //Console.WriteLine($"移库工单异常：工单号：{it.S_WorkNo.Trim()},工单类型：{it.S_ORDER_TYPE.Trim()}，移库数量：{it.S_YiKuNum}");
            }

            if (result)
            {
                ChangeWorkState(it, db);
                startList.ForEach(a =>
                {
                    var startrow = db.Queryable<Location>().Where(info => info.N_ROW.Trim() == a && info.S_LOCK_STATE == "移库锁").ToList();
                    foreach (var start in startrow)
                    {
                        start.S_LOCK_STATE = "无";
                        db.Updateable(start).UpdateColumns(ab => new { ab.S_LOCK_STATE }).ExecuteCommand();
                    }
                    TaskProcess.AreaRowLockState(a, false);
                });
                endList.ForEach(a =>
                {
                    var endrow = db.Queryable<Location>().Where(info => info.N_ROW.Trim() == a && info.S_LOCK_STATE == "移库锁").ToList();
                    foreach (var end in endrow)
                    {
                        end.S_LOCK_STATE = "无";
                        db.Updateable(end).UpdateColumns(ab => new { ab.S_LOCK_STATE }).ExecuteCommand();
                    }
                    TaskProcess.AreaRowLockState(a, false);
                });
            }
        }


        /// <summary>
        /// 更改工单状态为移库完成
        /// </summary>
        /// <param name="it"></param>
        /// <param name="db"></param>
        private static void ChangeWorkState(WorkOrder it, SqlSugar.SqlSugarClient db)
        {
            var work = db.Queryable<WorkOrder>().Where(a => a.S_WorkNo == it.S_WorkNo).First();
            if (work != null)
            {
                work.S_WorkState = "完成";
                db.Updateable(work).UpdateColumns(a => new { a.S_WorkState }).ExecuteCommand();
                LogHelper.Info($"移库任务完成：工单号:{it.S_WorkNo.Trim()}，工单类型:{it.S_ORDER_TYPE.Trim()}", "Monitor");
            }
        }

        #endregion


        #region   农夫山泉-淳安工厂

        /// <summary>
        /// 充电时间-24小时制
        /// </summary>
        public static string batteryStart = Settings.BatteryTime;
        public static string batteryEnd = Settings.BatteryTimeEnd;
        /// <summary>
        /// 自动充电
        /// </summary>
        internal static void AnalysisBattery()
        {
            LogHelper.Info("充电任务流程判断：执行开始！", "Monitor");
            var db = new SqlHelper<object>().GetInstance();
            var now = DateTime.Today;
            string date = now.Year.ToString() + "-" + now.Month.ToString() + "-" + now.Day.ToString() + " " + "12:00:00";
            DateTime dt = Convert.ToDateTime(date);
            string dateStart = now.Year.ToString() + "-" + now.Month.ToString() + "-" + now.Day.ToString() + " " + batteryStart;
            DateTime dtStart = Convert.ToDateTime(dateStart);
            string dateEnd = now.Year.ToString() + "-" + now.Month.ToString() + "-" + now.Day.ToString() + " " + batteryEnd;
            DateTime dtEnd = Convert.ToDateTime(dateEnd);
            if (dtStart.Subtract(dt).TotalMinutes > 0 && dtEnd.Subtract(dt).TotalMinutes < 0)
            {
                //晚上至凌晨时间段
                if (DateTime.Now.Subtract(dt).TotalMinutes > 0) dtEnd = Convert.ToDateTime(dateEnd).AddDays(1);//当前时间为夜晚--结束时间天数加1
                else dtStart = Convert.ToDateTime(dateStart).AddDays(-1);//当前时间为凌晨--开始时间天数减一
            }
            LogHelper.Info($"当前时间：{DateTime.Now},起始时间：{dtStart},结束时间：{dtEnd}", "Monitor");
            //Console.WriteLine($"【处理时间判断】：{DateTime.Now >= dtStart}，{DateTime.Now <= dtEnd}");
            if (DateTime.Now >= dtStart && DateTime.Now <= dtEnd)
            {
                //先判断中间表是否有当前充电桩的状态，有则不操作，反之进入小车电量查询
                LogHelper.Info("进入充电任务流程:当前时间满足生成充电任务基本要求，开始判断ChargingPile配置项中当前充电桩状态是否开启", "Monitor");//ChargingPile
                var list = Settings.GetChargingPile().Where(a => a.enable == "1").ToList();
                if (list.Count > 0)
                {
                    list.ForEach(a =>
                    {
                        var agvState = db.Queryable<HangChaAGV>().Where(b => b.agvNo == a.agvNo).First();
                        if (agvState != null)
                        {
                            int agvNo = int.Parse(a.agvNo);
                            var margin = db.Queryable<MarginAGV>().Where(b => b.agvNo == agvNo).First();
                            if (margin != null)
                            {
                                if (int.Parse(agvState.agvBattery.Trim()) <= 600)
                                {
                                    var count = db.Queryable<MarginAGV>().Where(b => b.state == 1).ToList();
                                    if (count.Count() == 0)
                                    {
                                        if (margin.state == 0)
                                        {
                                            var dic = new Dictionary<string, string>();
                                            dic.Add("Pri", "20");
                                            dic.Add("ExtDeviceNo", a.agvNo);
                                            dic.Add("FRow", "");
                                            dic.Add("TRow", "");
                                            dic.Add("No", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff:ffffff"));
                                            var res = NDC.AddNewOrder(1, dic);
                                            if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                                            {
                                                //推送成功，修改任务优先级
                                                margin.state = 1;
                                                db.Updateable(margin).ExecuteCommand();
                                                LogHelper.Info($"充电任务下发成功，车号：{a.agvNo}", "Monitor");
                                            }
                                        }
                                    }
                                }
                                else if (int.Parse(agvState.agvBattery.Trim()) >= 1000)
                                {
                                    margin.state = 2;
                                    db.Updateable(margin).ExecuteCommand();
                                }
                            }
                            else
                            {
                                int marginGroup = int.Parse(a.charginGroup);
                                var count = db.Queryable<MarginAGV>().Where(b => b.marginGroup == marginGroup && b.state == 1).ToList();
                                if (count.Count() == 0)
                                {
                                    MarginAGV marginAGV = new MarginAGV
                                    {
                                        agvNo = int.Parse(a.agvNo),
                                        marginGroup = int.Parse(a.charginGroup),
                                        state = 0,
                                        dateTime = DateTime.Now
                                    };
                                    db.Insertable(marginAGV).ExecuteCommand();
                                }
                            }
                        }
                    });
                }
            }
            else
            {
                //超过一小时，删除中间表全部数据
                db.Deleteable<MarginAGV>().Where(a => a.singNo == "1").ExecuteCommand();
                LogHelper.Info($"进入充电任务流程：当前时间不满足AMS推送小车充电，删除MarginAGV小车充电中间表！", "Monitor");
            }
            LogHelper.Info("充电任务流程判断：执行结束！", "Monitor");
        }





        #endregion

        #region   调试模式
        internal static void Test()
        {
            //var db = new SqlHelper<object>().GetInstance();
            //var listMaxCol = db.Queryable<Location>().Where(a => a.S_AREA_CODE == "CACK1" && a.N_ROW == 3).OrderByDescending(a => a.N_COL).First();
            ////Console.WriteLine(JsonConvert.SerializeObject(listMaxCol));

            //var trayInfoList = WCSHelper.GetChunAnTrayInfoList();
            ////Console.WriteLine(JsonConvert.SerializeObject(trayInfoList));
            //bool result = WCSHelper.DelChunAnTrayInfo("A01","10");
            ////Console.WriteLine(JsonConvert.SerializeObject(result));


            //var loca = IntensiveArea.GetLocationIn("CACK1", "塑料水", "202303150001");
            ////Console.WriteLine(JsonConvert.SerializeObject(loca));
            //WCSHelper.CreateTable();

            //var url = Settings.GetThirdPartyUrlList();
            //for (int i = 0; i < url.Count(); i++)
            //{
            //    //Console.WriteLine(url[i].Url);
            //}
        }
        #endregion
    }
}