11

cjs

2025-06-18 cb5c4a6e74c9cc070a67051256692b82c3c8b8f0

11

 HH.WCS.Mobox3.NongFuLinZhi/.vs/HH.WCS.Mobox3.NFLZ/v17/DocumentLayout.backup.json

New file
@@ -0,0 +1,65 @@
{
  "Version": 1,
  "WorkspaceRootPath": "C:\\software\\A-\u5DE5\u4F5C\\\u6E90\u7801\\GIT\\\u519C\u592B\u6797\u829D\\HH.WCS.Mobox3.NongFuLinZhi\\",
  "Documents": [],
  "DocumentGroupContainers": [
    {
      "Orientation": 0,
      "VerticalTabListWidth": 256,
      "DocumentGroups": [
        {
          "DockedWidth": 200,
          "SelectedChildIndex": -1,
          "Children": [
            {
              "$type": "Bookmark",
              "Name": "ST:0:0:{eefa5220-e298-11d0-8f78-00a0c9110057}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:0:0:{3ae79031-e1bc-11d0-8f78-00a0c9110057}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:130:0:{116d2292-e37d-41cd-a077-ebacac4c8cc4}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:128:0:{116d2292-e37d-41cd-a077-ebacac4c8cc4}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:0:0:{b1e99781-ab81-11d0-b683-00aa00a3ee26}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:129:0:{116d2292-e37d-41cd-a077-ebacac4c8cc4}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:0:0:{1c4feeaa-4718-4aa9-859d-94ce25d182ba}"
            }
          ]
        },
        {
          "DockedWidth": 22,
          "SelectedChildIndex": -1,
          "Children": [
            {
              "$type": "Bookmark",
              "Name": "ST:0:0:{d78612c7-9962-4b83-95d9-268046dad23a}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:0:0:{34e76e81-ee4a-11d0-ae2e-00a0c90fffc3}"
            },
            {
              "$type": "Bookmark",
              "Name": "ST:1:0:{e8034f19-ab72-4f06-83fd-f6832b41aa63}"
            }
          ]
        }
      ]
    }
  ]
}

 HH.WCS.Mobox3.NongFuLinZhi/Program.cs

@@ -98,7 +98,9 @@

                //tasks.Add(GetTask(Monitor.CheckDevice));
                tasks.Add(GetTask(Monitor.BottleBlankTransportation)); //接驳位入库
                //tasks.Add(GetTask(Monitor.BCPWorkSurveillance)); //半成品工单监控
                tasks.Add(GetTask(Monitor.PPFDFullIn)); //瓶坯翻斗机非急产满框区补满托
                tasks.Add(GetTask(Monitor.PGFDFullIn)); //瓶盖翻斗机非急产满框区补满托


                Task.WaitAll(tasks.ToArray());
            }

 HH.WCS.Mobox3.NongFuLinZhi/core/Monitor.cs

@@ -9,6 +9,7 @@
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static HH.WCS.Mobox3.NFLZ.wms.WMSHelper.AddChangeModel;
using static System.Runtime.CompilerServices.RuntimeHelpers;

namespace HH.WCS.Mobox3.NFLZ.core
@@ -60,10 +61,11 @@
                if (locInfo != null)
                {
                    LogHelper.Info($"【瓶盖满托转运】瓶坯接驳位查询到需入库的瓶坯，货位编码：{locInfo.S_CODE}");
                    if (locInfo.LocCntrRel != null)
                    string cntrCode = getCntrCode(db, locInfo);
                    if (string.IsNullOrEmpty(cntrCode))
                    {
                        //创建作业
                        WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "接驳位入库", locInfo.LocCntrRel.S_CNTR_CODE, "瓶盖");
                        WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "接驳位入库", cntrCode, "瓶盖");
                    }
                    else
                    {
@@ -77,15 +79,23 @@
            }
            #endregion

            #region 瓶坯空托入库
            #region 瓶盖空托入库
            areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产空框" && a.enable == 1).FirstOrDefault();
            if(areaInfo != null)
            {
                var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM == a.N_CAPACITY && a.S_LOCK_STATE == "无").Includes(a => a.LocCntrRel).First();
                if(locInfo != null && locInfo.LocCntrRel != null)
                var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM == a.N_CAPACITY && a.S_LOCK_STATE == "无").First();
                if(locInfo != null)
                {
                    string cntrCode = getCntrCode(db, locInfo);
                    if (string.IsNullOrEmpty(cntrCode))
                {
                    //创建作业
                    WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "瓶盖空托入库", locInfo.LocCntrRel.S_CNTR_CODE, "瓶盖");
                        WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "瓶盖空托入库", cntrCode, "瓶盖");
                    }
                    else
                    {
                        LogHelper.Info($"【瓶盖空托转运】当前货位未绑定托盘码，货位编码：{locInfo.S_CODE}");
                    }
                }
            }
            else
@@ -101,18 +111,16 @@
                var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM == a.N_CAPACITY && a.S_LOCK_STATE == "无").First();
                if (locInfo != null)
                {
                    string cntr = "";
                    var cntrList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locInfo.S_CODE).ToList();
                    if (cntrList.Count > 0)
                    string cntrCode = getCntrCode(db, locInfo);
                    if (!string.IsNullOrEmpty(cntrCode))
                    {
                        foreach (var a in cntrList)
                        {
                            cntr = cntr + a.S_CNTR_CODE + ",";
                        }
                    }
                    cntr = cntr.TrimEnd(',');
                    //创建作业
                    WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "接驳位入库", cntr, "瓶坯");
                        WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "接驳位入库", cntrCode, "瓶坯");
                    }
                    else
                    {
                        LogHelper.Info($"【瓶胚满托转运】当前货位未绑定托盘码，货位编码：{locInfo.S_CODE}");
                    }
                }
            }
            else
@@ -121,75 +129,49 @@
            }

            #endregion

        }

        /// <summary>
        /// 半成品工单监控
        /// 瓶坯翻斗机非急产满框区补满托
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        internal static void BCPWorkSurveillance()
        internal static void PPFDFullIn()
        {
            //瓶盖翻斗机工单
            //开启，查询 瓶盖非急产急用 物料是否满，不满则补充物料
            //关闭， 1、查询 瓶盖空托 是否还有托盘，有则入库  2、查询瓶盖非即产即用 是否有物料， 有则入库
            //瓶坯翻斗机
            //开启，查询是否为非即产即用，如果为非即产即用，则判断瓶坯非即产即用库区是否满， 不满则补空物料
            //关闭，查询 瓶坯非即产即用 瓶坯即产即用A 瓶坯即产即用B 是否有物料，有则入库
            //瓶坯注塑机
            //开启，查询 瓶坯空托 是否空托数量大于3托，如果不大于，则补空托
            //关闭，查询 瓶坯空托 是否有空托，有则入库



            //判断当前半成品工单是否有执行中的任务
            //工单类型： 1、农夫林芝-瓶坯机 2、农夫林芝-瓶盖翻斗机 3、农夫林芝-瓶坯翻斗机
            bool PPZUUSE = false; //瓶坯机是否使用
            bool PPFDUSE = false; //瓶坯翻斗机是否使用
            bool PGFDUSE = false; //瓶盖翻斗机是否使用

            //产线号 ： 农夫林芝-1号瓶坯翻斗机
            var db = new SqlHelper<object>().GetInstance();
            var workList = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_WorkState == "执行中").ToList();
            if (workList.Count > 0)
            var bcpWorkList = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_PLineNo.Contains("瓶坯翻斗机") && a.S_UsingNow == "N" && a.S_WorkState == "执行中").ToList();
            if(bcpWorkList.Count > 0)
            {
                foreach (var a in workList)
                bcpWorkList.ForEach(a => 
                {
                    if (a.S_PLineNo == "农夫林芝-瓶坯机")
                    string areaName = a.S_PLineNo.Split('-')[1].Substring(0, 1) + "号瓶胚翻斗机非即产满框";
                    var areaInfo = Settings.areaInfos.Where(b => b.areaName == areaName && b.enable == 1).FirstOrDefault();
                    if(areaInfo != null)
                    {
                        PPZUUSE = true;
                        var locInfo = db.Queryable<Location>().Where(b => b.S_AREA_CODE == areaInfo.areaCode && b.N_CURRENT_NUM == 0 && b.S_LOCK_STATE == "无").First();
                        if(locInfo != null)
                        {
                            //生成任务
                            Location location = TaskProcess.BCPInOrOut(db, false, "瓶坯库区", a.S_ItemCode);
                            if(location != null)
                            {
                                string cntrCode = getCntrCode(db,location);
                                //创建作业
                                WMSHelper.CreateOpTask(location.S_CODE, locInfo.S_CODE, "入库", "瓶坯非急产补满框", cntrCode, "瓶坯");
                    }
                    else if (a.S_PLineNo == "农夫林芝-瓶盖翻斗机")
                    {
                        PGFDUSE = true;
                        }
                    }
                    else
                    {
                        PPFDUSE = true;
                        LogHelper.Info($"{areaName}未配置");
                    }
                });
                }
            }

            //瓶坯机使用，则从 瓶坯库区 补充空托到 瓶坯空托 ，未使用，则将 瓶坯空托 的空托 移到 瓶坯库区
            //瓶坯翻斗机使用，则从 瓶坯库区 补充空托到 瓶坯即产即用/瓶坯非即产即用 ，未使用，则将 瓶坯即产即用/瓶坯非即产即用 的空托 移到 瓶坯库区
            //瓶盖翻斗机使用，则从 瓶盖库区 补充空托到 瓶坯非即产即用 ，未使用，则将 瓶坯非即产即用 的空托 移到 瓶盖库区

            TaskProcess.BCPYiKu(PPZUUSE, "瓶坯注塑机");
            TaskProcess.BCPYiKu(PPFDUSE, "瓶坯翻斗机");
            TaskProcess.BCPYiKu(PGFDUSE, "瓶盖翻斗机");

        }

        internal static void JBDEIN()
        {
            var db = new SqlHelper<object>().GetInstance();
            var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶胚入库接驳" && a.enable == 1).FirstOrDefault();
            if(areaInfo != null)
            {
                var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM == a.N_CAPACITY && a.S_LOCK_STATE == "无").First();
                if(locInfo != null)
        private static string getCntrCode(SqlSugar.SqlSugarClient db, Location location)
                {
                    string cntr = "";
                    var cntrList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locInfo.S_CODE).ToList();
            var cntrList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == location.S_CODE).OrderBy(a => a.T_CREATE).ToList();
                    if(cntrList.Count > 0)
                    {
                        foreach(var a in cntrList)
@@ -198,13 +180,124 @@
                        }
                    }
                    cntr = cntr.TrimEnd(',');
            return cntr;
        }

        internal static void PGFDFullIn()
        {
            //产线号 ： 农夫林芝-1号瓶盖翻斗机
            //瓶盖翻斗机共用一个库区，需要区分几种情况（注：现场已确认，三个翻斗机不会有三种物料）
            //1、如果三个翻斗机物料相同，则 瓶盖非即产满框 有空货位就补
            //2、如果三个翻斗机有两种不同的物料，则 瓶盖非即产满框 有空位的补充 改库区没有的物料
            var db = new SqlHelper<object>().GetInstance();
            string itemList = "";
            var bcpWorkList = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_PLineNo.Contains("瓶盖翻斗机") && a.S_UsingNow == "N" && a.S_WorkState == "执行中").ToList();
            if (bcpWorkList.Count > 0)
            {
                bcpWorkList.ForEach(a =>
                {
                    if (string.IsNullOrEmpty(itemList))
                    {
                        itemList = itemList + a.S_ItemCode + ",";
                    }
                    else
                    {
                        if (!itemList.Contains(a.S_ItemCode))
                        {
                            itemList = itemList + a.S_ItemCode + ",";
                        }
                    }
                });
            }
            if (!string.IsNullOrEmpty(itemList))
            {
                itemList = itemList.TrimEnd(',');
                List<string> itemCount = itemList.Split(',').ToList();
                if(itemCount.Count > 0)
                {
                    var areaInfo = Settings.areaInfos.Where(b => b.areaName == "瓶盖非即产满框" && b.enable == 1).FirstOrDefault();
                    if (areaInfo != null)
                    {
                        var locInfo = db.Queryable<Location>().Where(b => b.S_AREA_CODE == areaInfo.areaCode && b.N_CURRENT_NUM == 0 && b.S_LOCK_STATE == "无").First();
                        if (locInfo != null)
                        {
                            if (itemCount.Count == 1)
                            {
                                //只有一种物料
                                //生成任务
                                Location location = TaskProcess.BCPInOrOut(db, false, "瓶盖库区", itemCount[0]);
                                if (location != null)
                                {
                                    string cntrCode = getCntrCode(db, location);
                    //创建作业
                    WMSHelper.CreateOpTask(locInfo.S_CODE, "", "入库", "接驳位入库", cntr, "瓶坯");
                                    WMSHelper.CreateOpTask(location.S_CODE, locInfo.S_CODE, "入库", "瓶盖非急产补满框", cntrCode, "瓶盖");
                                }
                            }
                            if (itemCount.Count == 2)
                            {
                                //两种物料

                                //判断库区是否有货位数量大于0或者有入库锁的，如果有，则判断物料，如果没有，则生成第一个物料的任务
                                var locInfo2 = db.Queryable<Location>().Where(b => b.S_AREA_CODE == areaInfo.areaCode && (b.N_CURRENT_NUM > 0 || b.S_LOCK_STATE == "入库锁")).First();
                                if(locInfo2 != null)
                                {
                                    string itemCode = "";
                                    if(locInfo2.N_CURRENT_NUM > 0)
                                    {
                                        var cntrInfo = db.Queryable<LocCntrRel>().Where(b => b.S_LOC_CODE == locInfo2.S_CODE).First();
                                        if(cntrInfo != null)
                                        {
                                            var itemInfo = db.Queryable<CntrItemRel>().Where(b => b.S_CNTR_CODE == cntrInfo.S_CNTR_CODE).First();
                                            if(itemInfo != null)
                                            {
                                                itemCode = itemInfo.S_ITEM_CODE;
                                            }
                                        }
                                    }
                                    if(locInfo2.S_LOCK_STATE == "入库锁")
                                    {
                                        var taskInfo = db.Queryable<WMSTask>().Where(b => b.S_END_LOC == locInfo2.S_CODE && b.S_STATE != "完成" && b.S_STATE != "取消").First();
                                        if(taskInfo != null)
                                        {
                                            string cntrCode = taskInfo.S_CNTR_CODE.Split(',')[0];
                                            var itemInfo = db.Queryable<CntrItemRel>().Where(b => b.S_CNTR_CODE == cntrCode).First();
                                            if (itemInfo != null)
                                            {
                                                itemCode = itemInfo.S_ITEM_CODE;
                                            }
                                        }
                                    }

                                    if (itemCode != "")
                                    {
                                        itemCode = itemCode == itemCount[0] ? itemCount[1] : itemCount[0];
                                        Location location = TaskProcess.BCPInOrOut(db, false, "瓶盖库区", itemCode);
                                        if (location != null)
                                        {
                                            string cntrCode = getCntrCode(db, location);
                                            //创建作业
                                            WMSHelper.CreateOpTask(location.S_CODE, locInfo.S_CODE, "入库", "瓶盖非急产补满框", cntrCode, "瓶盖");
                                        }
                }
            }
            else
            {
                LogHelper.Info("瓶胚入库接驳 未配置");
                                    Location location = TaskProcess.BCPInOrOut(db, false, "瓶盖库区", itemCount[0]);
                                    if (location != null)
                                    {
                                        string cntrCode = getCntrCode(db, location);
                                        //创建作业
                                        WMSHelper.CreateOpTask(location.S_CODE, locInfo.S_CODE, "入库", "瓶盖非急产补满框", cntrCode, "瓶盖");
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info($"瓶盖非即产满框 未配置");
                    }
                }
            }
        }
    }

 HH.WCS.Mobox3.NongFuLinZhi/core/WMSCore.cs

@@ -65,7 +65,7 @@
                                var endinfo = db.Queryable<Location>().Where(it => it.S_CODE == end.S_CODE).First();
                                int startLayer = startinfo.N_CURRENT_NUM;
                                int endlayer = endinfo.N_CURRENT_NUM + 1;
                                if (a.S_OP_DEF_NAME == "接驳位入库" || a.S_OP_DEF_NAME == "瓶盖空托入库")
                                if (a.S_OP_DEF_NAME == "接驳位入库" || a.S_OP_DEF_NAME == "瓶盖空托入库" || a.S_OP_DEF_NAME == "瓶坯非急产补满框" || a.S_OP_DEF_NAME == "瓶盖非急产补满框")
                                {
                                    startLayer = 1;
                                    endlayer = 1;

 HH.WCS.Mobox3.NongFuLinZhi/process/DeviceProcess.cs

@@ -514,14 +514,13 @@
            {
                LogHelper.Info($"查询到执行中的工单，工单类型：{workInfo.S_PLineNo}");
                string startArea = "";
                string endArea = "";
                string fullTaskType = "";
                string emptyTaskType = "";
                if (workInfo.S_UsingNow == "Y")
                {
                    LogHelper.Info("即产即用工单");
                    //即产即用在起点为线边
                    var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯即产即用A" && a.enable == 1).FirstOrDefault();
                    var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶胚即产即用满框" && a.enable == 1).FirstOrDefault();
                    if (bcpInfo != null)
                    {
                        startArea = bcpInfo.areaCode;
@@ -533,7 +532,8 @@
                {
                    LogHelper.Info("非即产即用工单");
                    //非即产即用起点为库区
                    var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯非即产即用" && a.enable == 1).FirstOrDefault();
                    string areaName = plc.deviceName.Split('-')[1].Substring(0, 1) + "号瓶胚翻斗机非即产满框";
                    var bcpInfo = Settings.areaInfos.Where(a => a.areaName == areaName && a.enable == 1).FirstOrDefault();
                    if (bcpInfo != null)
                    {
                        startArea = bcpInfo.areaCode;
@@ -541,8 +541,6 @@
                    fullTaskType = "翻斗机库存满托上线（瓶坯）";
                    emptyTaskType = "翻斗机库存空托下线（瓶坯）";
                }

                endArea = Settings.areaInfos.Where(a => a.areaName == "瓶坯空托" && a.enable == 1).FirstOrDefault().areaCode;

                if (data.Length == 6)
                {
@@ -576,16 +574,12 @@
                                    //初始状态，无托盘，直接上满托(非即产即用需要校验 套袋完成，即产即用直接使用)
                                    if (workInfo.S_UsingNow == "Y")
                                    {
                                        LogHelper.Info($"瓶坯即产即用A库区查找");
                                        LogHelper.Info($"瓶胚即产即用满框 查找");
                                        startLoca = getFDSXArea(db, workInfo, startArea);
                                        if (startLoca == null)
                                        {
                                            LogHelper.Info($"瓶坯即产即用A库区未找到满托，去瓶坯即产即用B库区查找");
                                            startLoca = TaskProcess.BCPInOrOut(db, false, "瓶坯即产即用B", workInfo.S_ItemCode);
                                        }
                                    }
                                    else
                                    {
                                        LogHelper.Info($"瓶胚非即产库区 查找");
                                        startLoca = getFDSXArea(db, workInfo, startArea);
                                    }

@@ -643,12 +637,11 @@
            {
                LogHelper.Info($"查询到执行中的工单，工单类型：{workInfo.S_PLineNo}");
                string startArea = "";
                string endArea = "";
                string fullTaskType = "";
                string emptyTaskType = "";
                LogHelper.Info("非即产即用工单");
                //非即产即用起点为库区
                var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产即用" && a.enable == 1).FirstOrDefault();
                var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产满框" && a.enable == 1).FirstOrDefault();
                if (bcpInfo != null)
                {
                    startArea = bcpInfo.areaCode;
@@ -657,7 +650,6 @@
                fullTaskType = "翻斗机库存满托上线（瓶盖）";
                emptyTaskType = "翻斗机库存空托下线（瓶盖）";

                endArea = Settings.areaInfos.Where(a => a.areaName == "瓶盖空托" && a.enable == 1).FirstOrDefault().areaCode;
                if (data.Length == 6)
                {
                    if (data.Substring(0, 2) == "11")
@@ -695,9 +687,9 @@
                                }
                                else
                                {
                                    LogHelper.Info($"瓶盖翻斗机上有空托盘，生成空托下线任务，瓶盖翻斗机点位：{plc.TN_Location[0]}");
                                    LogHelper.Info($"瓶盖翻斗机上有空托盘，生成空托下线任务，瓶盖翻斗机点位：{locCode}");
                                    //创建作业
                                    WMSHelper.CreateOpTask(plc.TN_Location[0],"", "入库", emptyTaskType, plcLoca.S_CNTR_CODE);
                                    WMSHelper.CreateOpTask(locCode, "", "入库", emptyTaskType, plcLoca.S_CNTR_CODE);
                                }
                            }
                        }

 HH.WCS.Mobox3.NongFuLinZhi/process/TaskProcess.cs

@@ -677,10 +677,11 @@
            if (mst.S_TYPE.Contains("满托下线"))
            {
                LogHelper.Info($"空托任务生成处理，任务类型：{mst.S_TYPE}");
                var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯空托" && a.enable == 1).First();
                string areaName = mst.S_TYPE.Contains("库存") ? "瓶胚非即产空框" : "瓶胚即产空框";
                var areaInfo = Settings.areaInfos.Where(a => a.areaName == areaName && a.enable == 1).First();
                if(areaInfo != null)
                {
                    startLoca = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE == "无").OrderBy(a => a.N_COL).First();
                    startLoca = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE == "无").OrderBy(a => a.N_ROW).First();
                    if (startLoca != null)
                    {
                        LogHelper.Info("startLoca" + JsonConvert.SerializeObject(startLoca));
@@ -706,19 +707,12 @@
                LogHelper.Info($"满托任务生成处理，任务类型：{mst.S_TYPE}");
                string startArea = "";
                LinZhiBCPWorkOrder bcpW = null;
                if (mst.S_TYPE.Contains("瓶坯"))
                {
                    bcpW = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_PLineNo.Contains("农夫林芝-瓶坯翻斗机") && a.S_WorkState == "执行中").First();
                }
                else
                {
                    bcpW = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_PLineNo.Contains("农夫林芝-瓶盖翻斗机") && a.S_WorkState == "执行中").First();
                }
                bcpW = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_WorkNo == mst.S_WORK_NO && a.S_WorkState == "执行中").First();

                if (mst.S_TYPE.Contains("瓶盖"))
                {
                    //瓶盖无即产即用和非即产即用
                    var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产即用" && a.enable == 1).FirstOrDefault();
                    var bcpInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产满框" && a.enable == 1).FirstOrDefault();
                    if (bcpInfo != null)
                    {
                        startLoca = DeviceProcess.getFDSXArea(db, bcpW, bcpInfo.areaCode);
@@ -728,18 +722,14 @@
                {
                    if (bcpW.S_UsingNow == "Y")
                    {
                        LogHelper.Info($"瓶坯即产即用A库区查找");
                        startArea = Settings.areaInfos.Where(a => a.areaName == "瓶坯即产即用A" && a.enable == 1).FirstOrDefault().areaCode;
                        LogHelper.Info($"瓶胚即产满框 查找");
                        startArea = Settings.areaInfos.Where(a => a.areaName == "瓶胚即产满框" && a.enable == 1).FirstOrDefault().areaCode;
                        startLoca = DeviceProcess.getFDSXArea(db, bcpW, startArea);
                        if (startLoca == null)
                        {
                            LogHelper.Info($"瓶坯即产即用A库区未找到满托，去瓶坯即产即用B库区查找");
                            startLoca = TaskProcess.BCPInOrOut(db, true, "瓶坯即产即用B", bcpW.S_ItemCode);
                        }
                    }
                    else
                    {
                        startArea = Settings.areaInfos.Where(a => a.areaName == "瓶坯非即产即用" && a.enable == 1).FirstOrDefault().areaCode;
                        string areaName = bcpW.S_PLineNo.Split('-')[1].Substring(0, 1) + "号瓶胚翻斗机非即产满框";
                        startArea = Settings.areaInfos.Where(a => a.areaName == areaName && a.enable == 1).FirstOrDefault().areaCode;
                        startLoca = DeviceProcess.getFDSXArea(db, bcpW, startArea);
                    }
                }
@@ -1520,10 +1510,8 @@
                }
                if(result == null)
                {
                    //result = TaskProcess.BCPInOrOut(db, true, "瓶坯库区", itemCode);
                    result = getJBLoc(db, result);
                }

            }
            else
            {
@@ -1566,12 +1554,12 @@
        internal static Location BCPEmptyOut(SqlSugarClient db, string taskName)
        {
            Location result = null;
            //翻斗机库存空托下线（瓶盖）
            string endAreaName = taskName.Contains("瓶盖") ? "瓶盖空托" : "瓶坯空托";

            string endAreaName = taskName.Contains("瓶盖") ? "瓶盖非即产空框" : taskName.Contains("库存") ? "瓶胚非即产空框" : "瓶胚即产空框";
            var areaInfo = Settings.areaInfos.Where(a => a.areaName == endAreaName && a.enable == 1).FirstOrDefault();
            if(areaInfo != null)
            {
                var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM < a.N_CAPACITY && a.S_LOCK_STATE == "无").OrderBy(a => a.N_COL).First();
                var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM < a.N_CAPACITY && a.S_LOCK_STATE == "无").OrderBy(a => a.N_ROW).First();
                if(locInfo != null)
                {
                    result = locInfo;
@@ -1581,187 +1569,9 @@
            {
                LogHelper.Info($"{endAreaName}未配置");
            }
            
            return result;
        }

        /// <summary>
        /// 半成品移库
        /// </summary>
        /// <param name="action">true - 工单开启 false - 工单关闭</param>
        /// <param name="machine">设备</param>
        internal static void BCPYiKu(bool action, string machine)
        {
            var db = new SqlHelper<object>().GetInstance();
            Location startLoc = null;
            Location endLoc = null;
            if (action)
            {
                if(machine == "瓶坯翻斗机")
                {
                    //瓶坯翻斗机
                    //开启，判断工单类型，根据工单类型补充对应的库区 即产即用不补充
                    var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯非即产即用" && a.enable == 1).FirstOrDefault();
                    if (areaInfo != null)
                    {
                        var workInfo = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_PLineNo == "农夫林芝-瓶批翻斗机" && a.S_WorkState == "执行中").First();
                        if (workInfo.S_UsingNow == "N")
                        {
                            startLoc = TaskProcess.BCPInOrOut(db, false, "瓶坯库区", workInfo.S_ItemCode);
                            endLoc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM < a.N_CAPACITY && a.S_LOCK_STATE == "无").OrderBy(a => a.N_COL).First();
                        }
                    }
                    else
                    {
                        LogHelper.Info("瓶坯非即产即用未配置");
                    }
                        
                }
                if (machine == "瓶坯注塑机")
                {
                    //开启，查询 瓶坯空托 是否空托数量大于3托，如果不大于，则补空托
                    var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯注塑机空托" && a.enable == 1).FirstOrDefault();
                    if(areaInfo != null)
                    {
                        var locList = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE == "无").ToList();
                        if(locList.Count > 2)
                        {
                            LogHelper.Info("瓶坯空托 补空托");
                            startLoc = TaskProcess.BCPInOrOut(db, false, "瓶坯库区","");
                            endLoc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM < a.N_CAPACITY && a.S_LOCK_STATE == "无").OrderBy(a => a.N_COL).First();
                        }
                    }
                    else
                    {
                        LogHelper.Info("瓶坯注塑机空托未配置");
                    }

                }
                if (machine == "瓶盖翻斗机")
                {
                    //开启，查询 瓶盖非急产急用 物料是否满，不满则补充物料
                    var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产即用" && a.enable == 1).FirstOrDefault();
                    if (areaInfo != null)
                    {
                        var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM < a.N_CAPACITY && a.S_LOCK_STATE == "无").First();
                        if(locInfo != null)
                        {
                            LogHelper.Info("瓶盖非即产即用 补满托");
                            var workInfo = db.Queryable<LinZhiBCPWorkOrder>().Where(a => a.S_PLineNo == "农夫林芝-瓶盖翻斗机" && a.S_WorkState == "执行中").First();
                            startLoc = TaskProcess.BCPInOrOut(db, false, "瓶盖库区", workInfo.S_ItemCode);
                            endLoc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM < a.N_CAPACITY && a.S_LOCK_STATE == "无").OrderBy(a => a.N_COL).First();
                        }
                    }
                    else
                    {
                        LogHelper.Info("瓶盖非即产即用未配置");
                    }
                }
            }
            else
            {
                if (machine == "瓶坯翻斗机")
                {
                    //关闭，查询 瓶坯非即产即用 瓶坯即产即用A 瓶坯即产即用B 是否有物料，有则入库
                    var areaList = Settings.areaInfos.Where(a => (a.areaName == "瓶坯非即产即用" || a.areaName == "瓶坯即产即用A") && a.enable == 1).ToList();
                    if (areaList.Count > 0)
                    {
                        foreach(var a in areaList)
                        {
                            startLoc = db.Queryable<Location>().Where(b => b.S_AREA_CODE == a.areaCode && b.N_CURRENT_NUM > 0 && b.S_LOCK_STATE == "无").Includes(b => b.LocCntrRel).First();
                            if (startLoc != null) break;
                        }
                    }
                    if (startLoc == null)
                    {
                        var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯即产即用B" && a.enable == 1).FirstOrDefault();
                        if(areaInfo != null)
                        {
                            var locInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0).OrderBy(a => a.N_ROW).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).Includes(a => a.LocCntrRel).ToList();
                            if(locInfo.Count > 0)
                            {
                                foreach(var a in locInfo)
                                {
                                    int row = a.N_ROW;
                                    var lockInfo = db.Queryable<Location>().Where(b => b.S_AREA_CODE == areaInfo.areaCode && b.N_ROW == a.N_ROW && (b.S_LOCK_STATE == "入库锁" || b.S_LOCK_STATE == "出库锁")).First();
                                    if(lockInfo == null)
                                    {
                                        startLoc = a;
                                    }
                                }
                            }
                        }
                    }
                    if(startLoc != null)
                    {
                        if (startLoc.LocCntrRel != null)
                        {
                            var itemInfo = db.Queryable<CntrItemRel>().Where(a => a.S_CNTR_CODE == startLoc.LocCntrRel.S_CNTR_CODE).First();
                            if (itemInfo != null)
                            {
                                endLoc = TaskProcess.BCPInOrOut(db, true, "瓶坯库区", itemInfo.S_ITEM_CODE);
                            }
                        }
                    }
                }
                if (machine == "瓶坯注塑机")
                {
                    //关闭，查询 瓶坯空托 是否有空托，有则入库
                    var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶坯注塑机空托" && a.enable == 1).FirstOrDefault();
                    if (areaInfo != null)
                    {
                        startLoc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE == "无").Includes(a => a.LocCntrRel).First();
                        if(startLoc != null)
                        {
                            endLoc = TaskProcess.BCPInOrOut(db, true, "瓶坯库区", "");
                        }
                    }
                }
                if (machine == "瓶盖翻斗机")
                {
                    //关闭， 1、查询 瓶盖空托 是否还有托盘，有则入库  2、查询瓶盖非即产即用 是否有物料， 有则入库
                    //关闭，查询 瓶坯空托 是否有空托，有则入库

                    //查询空托库区
                    var areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖空托" && a.enable == 1).FirstOrDefault();
                    if (areaInfo != null)
                    {
                        startLoc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE == "无").Includes(a => a.LocCntrRel).First();
                        if (startLoc != null)
                        {
                            endLoc = TaskProcess.BCPInOrOut(db, true, "瓶盖库区", "");
                        }
                    }

                    //查询满托库区
                    if(startLoc == null)
                    {
                        areaInfo = Settings.areaInfos.Where(a => a.areaName == "瓶盖非即产即用" && a.enable == 1).FirstOrDefault();
                        if (areaInfo != null)
                        {
                            startLoc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaInfo.areaCode && a.N_CURRENT_NUM > 0 && a.S_LOCK_STATE == "无").Includes(a => a.LocCntrRel).First();
                            if (startLoc != null)
                            {
                                if(startLoc.LocCntrRel != null)
                                {
                                    var itemInfo = db.Queryable<CntrItemRel>().Where(a => a.S_CNTR_CODE == startLoc.LocCntrRel.S_CNTR_CODE).First();
                                    if(itemInfo != null)
                                    {
                                        endLoc = TaskProcess.BCPInOrOut(db, true, "瓶盖库区", itemInfo.S_ITEM_CODE);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            if (startLoc != null && endLoc != null)
            {
                WMSHelper.CreateOpTask(startLoc.S_CODE, endLoc.S_CODE, "入库", "半成品移库", startLoc.LocCntrRel.S_CNTR_CODE);
            }
        }



        /// <summary>
        /// FuLeWebPost

 HH.WCS.Mobox3.NongFuLinZhi/wms/LocationHelper.cs

@@ -339,7 +339,7 @@
                    location.N_CURRENT_NUM = 0;
                }

                if (type == "接驳位入库" || type == "瓶盖空托入库")
                if (type == "接驳位入库" || type == "瓶盖空托入库" || type == "瓶坯非急产补满框" || type == "瓶盖非急产补满框")
                {
                    location.N_CURRENT_NUM = 0;
                }
@@ -382,7 +382,7 @@
                    }
                });
                location.N_CURRENT_NUM = lcrList.Count + count;
                if(type == "接驳位入库" || type == "瓶盖空托入库")
                if(type == "接驳位入库" || type == "瓶盖空托入库" || type == "瓶坯非急产补满框" || type == "瓶盖非急产补满框")
                {
                    location.N_CURRENT_NUM = location.N_CAPACITY;
                }