合肥佳通问题优化

lss

2025-06-06 8674dabad31db77cba438ab1746235fa41c08716

 HH.WCS.Mobox3/HH.WCS.Mobox3.JiaTong/api/ApiHelper.cs

@@ -34,6 +34,8 @@


        #region 佳通合肥接口业务

       
        /// <summary>
        /// 立库任务下发=》创建任务
        /// </summary>
@@ -177,6 +179,13 @@
                        //}

                    }
                    else
                    {
                        result.code = "1";
                        result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
                        AddErrorInfo("货位查找失败", result.msg, Source);
                        return result;
                    }

                    endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
                    if (endloc != null)
@@ -273,7 +282,7 @@
                            LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
                            if (WCSHelper.CreateTask(wcsTask))
                            {
                             //   LocationHelper.LockLoc(End, 2);
                                //   LocationHelper.LockLoc(End, 2);

                                LogHelper.Info("创建任务成功");
                            }
@@ -566,7 +575,7 @@
                        LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                           // LocationHelper.LockLoc(Start, 2);
                            // LocationHelper.LockLoc(Start, 2);
                            //LocationHelper.LockLoc(End, 1);
                            LogHelper.Info("创建任务成功");
                        }
@@ -1089,6 +1098,7 @@
                        N_START_LAYER = 1,
                        N_END_LAYER = 1,
                        Z_TYPE = n_type

                    };
                    LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
                    if (WCSHelper.CreateTask(wcsTask))
@@ -1125,6 +1135,7 @@

        }

        public static object _lockEmpty = new object();
        /// <summary>
        /// 空工装回库
        /// </summary>
@@ -1155,200 +1166,204 @@

            try
            {
                #region 判断托盘绑定货位是否和下发绑定起点相同
                //var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                //if (CntrLoc != null)
                //{
                //    if (CntrLoc.S_LOC_CODE != Start)
                //    {
                //        LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}");
                //        result.code = "1";
                //        result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
                //        AddErrorInfo("托盘绑定位置不同", result.msg);
                //        return result;
                //    }
                //}
                //else
                //{
                //    LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}未找到绑定货位");
                //    result.code = "1";
                //    result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
                //    AddErrorInfo("查找托盘货位失败", result.msg);
                //    return result;
                //}
                #endregion

                #region 根据货位楼层判断，3楼去往叠盘位 其他的回库
                var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
                if (startloc != null)
                lock (_lockEmpty)
                {
                    if (startloc.N_LAYER == 3)
                    #region 判断托盘绑定货位是否和下发绑定起点相同
                    //var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                    //if (CntrLoc != null)
                    //{
                    //    if (CntrLoc.S_LOC_CODE != Start)
                    //    {
                    //        LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}");
                    //        result.code = "1";
                    //        result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
                    //        AddErrorInfo("托盘绑定位置不同", result.msg);
                    //        return result;
                    //    }
                    //}
                    //else
                    //{
                    //    LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}未找到绑定货位");
                    //    result.code = "1";
                    //    result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
                    //    AddErrorInfo("查找托盘货位失败", result.msg);
                    //    return result;
                    //}
                    #endregion

                    #region 根据货位楼层判断，3楼去往叠盘位 其他的回库
                    var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
                    if (startloc != null)
                    {
                        //叠盘货位计算叠盘货位
                        var dploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "叠盘" && a.N_LAYER == startloc.N_LAYER && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
                        if (dploc.Count > 0)
                        if (startloc.N_LAYER == 3)
                        {
                            // LogHelper.Info($"获取叠盘货位:{JsonConvert.SerializeObject(dploc)}");
                            loc = dploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
                            if (loc == null)
                            //叠盘货位计算叠盘货位
                            var dploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "叠盘" && a.N_LAYER == startloc.N_LAYER && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
                            if (dploc.Count > 0)
                            {
                                result.code = "1";
                                result.msg = $"叠盘货位不可用";
                                AddErrorInfo("查找库区失败", result.msg, Source);
                                return result;
                                // LogHelper.Info($"获取叠盘货位:{JsonConvert.SerializeObject(dploc)}");
                                loc = dploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
                                if (loc == null)
                                {
                                    result.code = "1";
                                    result.msg = $"叠盘货位不可用";
                                    AddErrorInfo("查找库区失败", result.msg, Source);
                                    return result;
                                }
                                else
                                {
                                    endlayer = loc.N_CURRENT_NUM + 1;
                                }
                            }
                            else
                            {
                                endlayer = loc.N_CURRENT_NUM + 1;

                                result.code = "1";
                                result.msg = $"叠盘货位不可用";
                                LogHelper.Info($"根据货位备注：叠盘，货位楼层:{startloc.N_LAYER},货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
                                AddErrorInfo("查找货位失败", result.msg, Source);
                                return result;
                            }
                        }
                        else if (startloc.S_NOTE == "PB")
                        {
                            //找块胶堆叠区
                            var KjDploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "片胶堆叠位" && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
                            if (KjDploc.Count > 0)
                            {
                                loc = KjDploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
                                if (loc == null)
                                {
                                    result.code = "1";
                                    result.msg = $"叠盘货位不可用";
                                    AddErrorInfo("查找库区失败", result.msg, Source);
                                    return result;
                                }
                                else
                                {
                                    endlayer = loc.N_CURRENT_NUM + 1;
                                }
                            }
                            else
                            {
                                LogHelper.Info($"根据货位备注：片胶堆叠位,货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
                                result.code = "1";
                                result.msg = $"叠盘货位不可用";
                                AddErrorInfo("查找货位失败", result.msg, Source);
                                return result;
                            }
                        }
                        else
                        {
                            #region 根据起点货位类型，获得回库库区
                            //根据仓库 计算库区
                            var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
                            if (whcode != null)
                            {
                                if (string.IsNullOrEmpty(startloc.S_NOTE))
                                {
                                    areacode = whcode.PMK;
                                }
                            }
                            else
                            {
                                result.code = "1";
                                result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
                                LogHelper.Info($"Putin==> {result.msg}");
                                AddErrorInfo("查找库区失败", result.msg, Source);
                                return result;
                            }
                            #endregion

                            //回库货位计算库区货位
                            loc = StorageCompute(itemcode, areacode);
                            //if (loc == null)
                            //{
                            //    loc = emptyRow(areacode);
                            //    if (loc == null)
                            //    {
                            //        LogHelper.Info($"库区：{areacode}没有空排");
                            //    }
                            //}
                            //else
                            //{

                            //    result.code = "1";
                            //    result.msg = $"库区:{areacode}无可用货位";
                            //    LogHelper.Info($"{result.msg}");
                            //    AddErrorInfo("查找货位失败", result.msg, Source);
                            //    return result;
                            //}
                        }

                    }
                    else
                    {

                        result.code = "1";
                        result.msg = $"Empty==> 任务起点:{Start}找不到对应货位，请检查货位表";
                        LogHelper.Info($"{result.msg}");
                        AddErrorInfo("查找货位失败", result.msg, Source);
                        return result;
                    }
                    #endregion

                    #region 创建任务
                    if (startloc != null && loc != null)
                    {
                        if (startloc.N_LOCK_STATE != 0 && loc.N_LOCK_STATE != 0)
                        {
                            result.code = "1";
                            result.msg = $"叠盘货位不可用";
                            LogHelper.Info($"根据货位备注：叠盘，货位楼层:{startloc.N_LAYER},货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
                            AddErrorInfo("查找货位失败", result.msg, Source);
                            result.msg = $"创建任务失败，起点货位状态{startloc.N_LOCK_STATE},起点货位状态：{loc.N_LOCK_STATE}";
                            AddErrorInfo("货位有锁", result.msg);
                            return result;
                        }
                    }
                    else if (startloc.S_NOTE == "PB")
                    {
                        //找块胶堆叠区
                        var KjDploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "片胶堆叠位" && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
                        if (KjDploc.Count > 0)
                        //创建wcs任务
                        var wcsTask = new WCSTask
                        {
                            loc = KjDploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
                            if (loc == null)
                            {
                                result.code = "1";
                                result.msg = $"叠盘货位不可用";
                                AddErrorInfo("查找库区失败", result.msg, Source);
                                return result;
                            }
                            else
                            {
                                endlayer = loc.N_CURRENT_NUM + 1;
                            }
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_TYPE = "空工装回库",
                            S_EQ_NO = model.TaskNumber,
                            S_START_LOC = startloc.S_CODE,
                            S_END_LOC = loc.S_CODE,
                            S_START_WH = startloc.S_WH_CODE,
                            S_START_AREA = startloc.S_AREA_CODE,
                            S_END_WH = loc.S_WH_CODE,
                            S_END_AREA = loc.S_AREA_CODE,
                            N_CNTR_COUNT = 1,
                            N_SCHEDULE_TYPE = 1,
                            S_CNTR_CODE = model.Rfid,
                            N_START_LAYER = 1,
                            N_END_LAYER = endlayer,
                            Z_TYPE = 5
                        };
                        LogHelper.Info("创建空托回库任务：" + JsonConvert.SerializeObject(wcsTask));
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            //LocationHelper.LockLoc(startloc.S_CODE, 2);
                            //LocationHelper.LockLoc(loc.S_CODE, 1);
                            //  空托回库判断托盘有无绑定物料信息 如果有则删除
                            var itemcntr = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                            if (itemcntr != null) { db.Deleteable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).ExecuteCommand(); }
                            LogHelper.Info("创建任务成功");
                        }
                        else
                        {
                            LogHelper.Info($"根据货位备注：片胶堆叠位,货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
                            result.code = "1";
                            result.msg = $"叠盘货位不可用";
                            AddErrorInfo("查找货位失败", result.msg, Source);
                            result.msg = $"任务创建失败";
                            AddErrorInfo("任务创建失败", result.msg, Source);
                            return result;
                        }
                    }
                    else
                    {
                        #region 根据起点货位类型，获得回库库区
                        //根据仓库 计算库区
                        var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
                        if (whcode != null)
                        {
                            if ( string.IsNullOrEmpty(startloc.S_NOTE))
                            {
                                areacode = whcode.PMK;
                            }
                        }
                        else
                        {
                            result.code = "1";
                            result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
                            LogHelper.Info($"Putin==> {result.msg}");
                            AddErrorInfo("查找库区失败", result.msg, Source);
                            return result;
                        }
                        #endregion

                        //回库货位计算库区货位
                        loc = StorageCompute(itemcode, areacode);
                        //if (loc == null)
                        //{
                        //    loc = emptyRow(areacode);
                        //    if (loc == null)
                        //    {
                        //        LogHelper.Info($"库区：{areacode}没有空排");
                        //    }
                        //}
                        //else
                        //{

                        //    result.code = "1";
                        //    result.msg = $"库区:{areacode}无可用货位";
                        //    LogHelper.Info($"{result.msg}");
                        //    AddErrorInfo("查找货位失败", result.msg, Source);
                        //    return result;
                        //}
                    }

                }
                else
                {

                    result.code = "1";
                    result.msg = $"Empty==> 任务起点:{Start}找不到对应货位，请检查货位表";
                    LogHelper.Info($"{result.msg}");
                    AddErrorInfo("查找货位失败", result.msg, Source);
                    return result;
                }
                #endregion

                #region 创建任务
                if (startloc != null && loc != null)
                {
                    if (startloc.N_LOCK_STATE != 0 && loc.N_LOCK_STATE != 0)
                    {
                        result.code = "1";
                        result.msg = $"创建任务失败，起点货位状态{startloc.N_LOCK_STATE},起点货位状态：{loc.N_LOCK_STATE}";
                        AddErrorInfo("货位有锁", result.msg);
                        result.msg = "创建任务失败，未找到对应的取货点或卸货点";
                        return result;
                    }
                    //创建wcs任务
                    var wcsTask = new WCSTask
                    {
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = "空工装回库",
                        S_EQ_NO = model.TaskNumber,
                        S_START_LOC = startloc.S_CODE,
                        S_END_LOC = loc.S_CODE,
                        S_START_WH = startloc.S_WH_CODE,
                        S_START_AREA = startloc.S_AREA_CODE,
                        S_END_WH = loc.S_WH_CODE,
                        S_END_AREA = loc.S_AREA_CODE,
                        N_CNTR_COUNT = 1,
                        N_SCHEDULE_TYPE = 1,
                        S_CNTR_CODE = model.Rfid,
                        N_START_LAYER = 1,
                        N_END_LAYER = endlayer,
                        Z_TYPE = 5
                    };
                    LogHelper.Info("创建空托回库任务：" + JsonConvert.SerializeObject(wcsTask));
                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        //LocationHelper.LockLoc(startloc.S_CODE, 2);
                        //LocationHelper.LockLoc(loc.S_CODE, 1);
                        //  空托回库判断托盘有无绑定物料信息 如果有则删除
                        var itemcntr = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                        if (itemcntr != null) { db.Deleteable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).ExecuteCommand(); }
                        LogHelper.Info("创建任务成功");
                    }
                    else
                    {
                        result.code = "1";
                        result.msg = $"任务创建失败";
                        AddErrorInfo("任务创建失败", result.msg, Source);
                        return result;
                    }
                    #endregion
                }
                else
                {
                    result.code = "1";
                    result.msg = "创建任务失败，未找到对应的取货点或卸货点";
                    return result;
                }
                #endregion

            }
            catch (Exception ex)
            {
@@ -1360,6 +1375,8 @@

            return result;
        }

        public static object _lockcallfixture = new object();

        /// <summary>
        /// 空工装呼叫
@@ -1382,7 +1399,7 @@
            #region 变量
            string Start = "";
            string End = model.TargetLocation;
            string itemcode = "";
            
            string areacode = "";
            string cntrcode = "";
            Location startloc = new Location();
@@ -1390,113 +1407,117 @@

            try
            {
                #region 根据仓库编码判断库区 并计算出库货位
                var endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == End).First();
                //根据仓库 计算库区

                if (endloc != null)
                lock (_lockcallfixture)
                {
                    var whcode = Settings.wareLoc.Where(a => a.AreaCode == endloc.S_WH_CODE).FirstOrDefault();
                    if (whcode != null)
                    {
                        areacode = whcode.PMK;
                    }
                    else
                    {
                        result.code = "1";
                        result.msg = $"根据起点仓库编码：{endloc.S_WH_CODE}未找到对应配置文件";
                        LogHelper.Info($"Putin==> {result.msg}");
                        AddErrorInfo("查找库区失败", result.msg, Source);
                        return result;
                    }
                    #region 根据仓库编码判断库区 并计算出库货位
                    var endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == End).First();
                    //根据仓库 计算库区


                    //计算出库托盘
                    startloc = LocationHelper.GetLocByAreacode(areacode);
                    if (startloc != null)
                    if (endloc != null)
                    {
                        var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
                        if (cntr != null)
                        var whcode = Settings.wareLoc.Where(a => a.AreaCode == endloc.S_WH_CODE).FirstOrDefault();
                        if (whcode != null)
                        {
                            Start = cntr.S_LOC_CODE;
                            cntrcode = cntr.S_CNTR_CODE;
                            areacode = whcode.PMK;
                        }
                        else
                        {
                            result.code = "1";
                            result.msg = $"创建空工装呼叫任务==>根据货位{endloc.S_CODE}未找到托盘货位绑定关系";
                            LogHelper.Info($"callfixture:{result.msg}");
                            AddErrorInfo("查找托盘失败", result.msg, Source);
                            result.msg = $"根据起点仓库编码：{endloc.S_WH_CODE}未找到对应配置文件";
                            LogHelper.Info($"Putin==> {result.msg}");
                            AddErrorInfo("查找库区失败", result.msg, Source);
                            return result;
                        }
                        

                        //计算出库托盘
                        startloc = LocationHelper.GetLocByAreacode(areacode,model.CarrierType);
                        if (startloc != null)
                        {
                            var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
                            if (cntr != null)
                            {
                                Start = cntr.S_LOC_CODE;
                                cntrcode = cntr.S_CNTR_CODE;
                            }
                            else
                            {
                                result.code = "1";
                                result.msg = $"创建空工装呼叫任务==>根据货位{endloc.S_CODE}未找到托盘货位绑定关系";
                                LogHelper.Info($"callfixture:{result.msg}");
                                AddErrorInfo("查找托盘失败", result.msg, Source);
                                return result;
                            }

                        }

                    }

                }
                else
                {

                    result.code = "1";
                    result.msg = $"任务起点:{End}找不到对应货位，请检查货位表";
                    LogHelper.Info($"callfixture:{result.msg}");
                    AddErrorInfo("查找货位失败", result.msg, Source);
                    return result;
                }
                #endregion

                #region 创建任务
                if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
                {
                    if (startloc.N_LOCK_STATE != 0)
                    else
                    {

                        result.code = "1";
                        result.msg = $"创建任务失败，起点{Start}有锁";
                        AddErrorInfo("货位有锁", result.msg);
                        result.msg = $"任务起点:{End}找不到对应货位，请检查货位表";
                        LogHelper.Info($"callfixture:{result.msg}");
                        AddErrorInfo("查找货位失败", result.msg, Source);
                        return result;
                    }
                    //创建wcs任务
                    var wcsTask = new WCSTask
                    {
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = "空工装呼叫",
                        S_EQ_NO = model.TaskNumber,
                        S_START_LOC = Start,
                        S_END_LOC = End,
                        S_START_WH = startloc.S_WH_CODE,
                        S_START_AREA = startloc.S_AREA_CODE,
                        S_END_WH = endloc.S_WH_CODE,
                        S_END_AREA = endloc.S_AREA_CODE,
                        N_CNTR_COUNT = 1,
                        N_SCHEDULE_TYPE = 1,
                        S_CNTR_CODE = cntrcode,
                        N_START_LAYER = 1,
                        N_END_LAYER = 1,
                        Z_TYPE = 5
                    #endregion

                    };
                    LogHelper.Info("创建呼叫空托任务：" + JsonConvert.SerializeObject(wcsTask));
                    if (WCSHelper.CreateTask(wcsTask))
                    #region 创建任务
                    if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
                    {
                        //LocationHelper.LockLoc(Start, 2);
                        //LocationHelper.LockLoc(End, 1);
                        LogHelper.Info("创建任务成功");
                        if (startloc.N_LOCK_STATE != 0)
                        {
                            result.code = "1";
                            result.msg = $"创建任务失败，起点{Start}有锁";
                            AddErrorInfo("货位有锁", result.msg);
                            return result;
                        }
                        //创建wcs任务
                        var wcsTask = new WCSTask
                        {
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_TYPE = "空工装呼叫",
                            S_EQ_NO = model.TaskNumber,
                            S_START_LOC = Start,
                            S_END_LOC = End,
                            S_START_WH = startloc.S_WH_CODE,
                            S_START_AREA = startloc.S_AREA_CODE,
                            S_END_WH = endloc.S_WH_CODE,
                            S_END_AREA = endloc.S_AREA_CODE,
                            N_CNTR_COUNT = 1,
                            N_SCHEDULE_TYPE = 1,
                            S_CNTR_CODE = cntrcode,
                            N_START_LAYER = 1,
                            N_END_LAYER = 1,
                            Z_TYPE = 5,
                            S_NOTE = "粉料"
                        };
                        LogHelper.Info("创建呼叫空托任务：" + JsonConvert.SerializeObject(wcsTask));
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            //LocationHelper.LockLoc(Start, 2);
                            //LocationHelper.LockLoc(End, 1);
                            LogHelper.Info("创建任务成功");
                        }
                        else
                        {
                            result.code = "1";
                            result.msg = $"任务创建失败";
                            AddErrorInfo("任务创建失败", result.msg, Source);
                            return result;
                        }
                    }
                    else
                    {
                        result.code = "1";
                        result.msg = $"任务创建失败";
                        AddErrorInfo("任务创建失败", result.msg, Source);
                        result.msg = "创建任务失败，未找到对应的取货点或卸货点";
                        return result;
                    }
                }
                else
                {
                    result.code = "1";
                    result.msg = "创建任务失败，未找到对应的取货点或卸货点";
                    return result;
                    #endregion
                }
                return result;
                #endregion


            }
            catch (Exception ex)
@@ -1511,6 +1532,7 @@

        }

        public static object _lockItemBack = new object();
        /// <summary>
        /// 余料返回
        /// </summary>
@@ -1542,214 +1564,242 @@

            try
            {
                #region 余料返回根据托盘找出库任务
                //余料返回根据托盘找出库任务
                //msts = WCSHelper.GetTaskBycntrcode(model.Rfid);
                //if (msts.Count() > 0)
                //{
                //    msts.RemoveAll(a => string.IsNullOrEmpty(a.S_CNTR_CODE));
                //    mst = msts.OrderByDescending(a => a.T_CREATE).FirstOrDefault();
                //}
                //if (mst != null)
                //{
                //    areacode = mst.S_START_AREA;
                //}
                //else
                //{
                //    result.code = "1";
                //    result.msg = $"创建任务失败，根据托盘编码{model.Rfid}未找到托盘出库任务";
                //    AddErrorInfo("查找任务失败", result.msg);
                //    return result;
                //}
                //if (string.IsNullOrEmpty(areacode))
                //{
                //    LogHelper.Info($"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空");
                //    result.code = "1";
                //    result.msg = $"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空";
                //    AddErrorInfo("查找库区失败", result.msg);
                //    return result;
                //}
                #endregion

                #region 根据物料编码 判断回库还是回到对应暂存区 
                var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
                if (startloc != null)
                lock (_lockItemBack)
                {
                    var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
                    if (whcode != null)
                    #region 余料返回根据托盘找出库任务
                    //余料返回根据托盘找出库任务
                    //msts = WCSHelper.GetTaskBycntrcode(model.Rfid);
                    //if (msts.Count() > 0)
                    //{
                    //    msts.RemoveAll(a => string.IsNullOrEmpty(a.S_CNTR_CODE));
                    //    mst = msts.OrderByDescending(a => a.T_CREATE).FirstOrDefault();
                    //}
                    //if (mst != null)
                    //{
                    //    areacode = mst.S_START_AREA;
                    //}
                    //else
                    //{
                    //    result.code = "1";
                    //    result.msg = $"创建任务失败，根据托盘编码{model.Rfid}未找到托盘出库任务";
                    //    AddErrorInfo("查找任务失败", result.msg);
                    //    return result;
                    //}
                    //if (string.IsNullOrEmpty(areacode))
                    //{
                    //    LogHelper.Info($"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空");
                    //    result.code = "1";
                    //    result.msg = $"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空";
                    //    AddErrorInfo("查找库区失败", result.msg);
                    //    return result;
                    //}
                    #endregion

                    #region 判断托盘绑定货位是否和下发绑定起点相同
                    var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                    if (CntrLoc != null)
                    {
                        //粉料直接回库，其他物料需要去对应的暂存区
                        #region 根据物料判断回库库区
                        if (model.PartNumber.StartsWith("4X"))
                        if (CntrLoc.S_LOC_CODE != Start)
                        {
                            areacode = whcode.PMK;
                            //loc = StorageCompute(itemcode, areacode);
                            //if (loc == null)
                            //{
                            //    loc = emptyRow(areacode);
                            //}

                            result.code = "1";
                            result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
                            LogHelper.Info($"ItemBack：{result.msg}");
                            AddErrorInfo("托盘绑定位置不同", result.msg, Source);
                            return result;
                        }
                        else
                    }
                    else
                    {
                        if (db.Updateable(new LocCntrRel() { S_CNTR_CODE = model.Rfid, S_LOC_CODE = Start }).UpdateColumns().ExecuteCommand() <= 0)
                        {
                            #region 判断托盘绑定货位是否和下发绑定起点相同
                            var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                            if (CntrLoc != null)
                            result.code = "1";
                            result.msg = $"创建任务失败，托盘:{model.Rfid}绑定货位{Start}失败";
                            LogHelper.Info($"ItemBack：{result.msg}");
                            AddErrorInfo("托盘绑定货位失败", result.msg, Source);
                            return result;
                        }

                    }
                    #endregion

                    #region 根据物料编码 判断回库还是回到对应暂存区 
                    var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
                    if (startloc != null)
                    {
                        var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
                        if (whcode != null)
                        {
                            //粉料直接回库，其他物料需要去对应的暂存区
                            #region 根据物料判断回库库区
                            if (model.PartNumber.StartsWith("4X"))
                            {
                                if (CntrLoc.S_LOC_CODE != Start)
                                areacode = whcode.PMK;
                                //loc = StorageCompute(itemcode, areacode);
                                //if (loc == null)
                                //{
                                //    loc = emptyRow(areacode);
                                //}
                            }
                            else
                            {


                                if (model.PartNumber.StartsWith("3"))
                                {
                                    areacode = whcode.ZCW;
                                }
                                else
                                {

                                    result.code = "1";
                                    result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
                                    result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
                                    LogHelper.Info($"ItemBack：{result.msg}");
                                    AddErrorInfo("托盘绑定位置不同", result.msg, Source);
                                    AddErrorInfo("物料编码格式错误", result.msg, Source);
                                    return result;
                                }
                            }
                            else
                            {

                                result.code = "1";
                                result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
                                LogHelper.Info($"ItemBack：{result.msg}");
                                AddErrorInfo("查找托盘货位失败", result.msg, Source);
                                return result;

                            }
                            #endregion

                            if (model.PartNumber.StartsWith("3"))

                            var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == areacode).ToList();
                            //查找货位库区
                            if (EndLocs.Count > 0)
                            {
                                areacode = whcode.ZCW;
                                //loc =  EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
                                loc = FindEndcolByLocList(EndLocs);


                            }
                            else
                            {

                                result.code = "1";
                                result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
                                LogHelper.Info($"ItemBack：{result.msg}");
                                AddErrorInfo("物料编码格式错误", result.msg, Source);
                                result.msg = $"根据终点库区：{areacode},未找到对应货位";
                                AddErrorInfo("查找库区失败", result.msg, Source);
                                return result;
                            }


                        }
                        #endregion


                        var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == areacode).ToList();
                        //查找货位库区
                        if (EndLocs.Count > 0)
                        {
                            //loc =  EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
                            loc = FindEndcolByLocList(EndLocs);

                            if (loc != null)
                            {
                                End = loc.S_CODE;
                            }
                            else
                            {
                                result.code = "1";
                                result.msg = $"库区:{areacode}无可用货位";
                                AddErrorInfo("查找货位失败", result.msg, Source);
                                return result;
                            }

                        }
                        else
                        {

                            result.code = "1";
                            result.msg = $"根据终点库区：{areacode},未找到对应货位";
                            result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
                            LogHelper.Info($"Putin==> {result.msg}");
                            AddErrorInfo("查找库区失败", result.msg, Source);
                            return result;
                        }

                        if (loc != null)
                    }
                    else
                    {

                        result.code = "1";
                        result.msg = $"货位:{Start}找不到对应货位";
                        AddErrorInfo("查找货位失败", result.msg, Source);
                        return result;
                    }

                    #endregion

                    #region 创建任务
                    if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
                    {
                        if (startloc.N_LOCK_STATE != 0)
                        {
                            End = loc.S_CODE;
                            result.code = "1";
                            result.msg = $"创建任务失败，起点{Start}有锁";
                            AddErrorInfo("货位有锁", result.msg);
                            return result;
                        }
                        //创建wcs任务
                        var wcsTask = new WCSTask
                        {
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_TYPE = "余料返回",
                            S_EQ_NO = model.TaskNumber,
                            S_START_LOC = Start,
                            S_END_LOC = End,
                            S_START_WH = startloc.S_WH_CODE,
                            S_START_AREA = startloc.S_AREA_CODE,
                            S_END_WH = loc.S_WH_CODE,
                            S_END_AREA = loc.S_AREA_CODE,
                            N_CNTR_COUNT = 1,
                            N_SCHEDULE_TYPE = 1,
                            S_CNTR_CODE = model.Rfid,
                            N_START_LAYER = 1,
                            N_END_LAYER = 1,
                            Z_TYPE = 5

                        };
                        LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            //LocationHelper.LockLoc(Start, 2);
                            //LocationHelper.LockLoc(End, 1);
                            //创建任务成功 更新余料信息
                            var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                            if (CntrItem != null)
                            {
                                CntrItem.F_WEIGHT = model.LotList[0].Weight.ToString();
                                CntrItem.S_BS_TYPE = "余料";
                                CntrItem.F_QTY = float.Parse(model.LotList[0].qty);
                                CntrItem.S_ITEM_STATE = model.LotList[0].QualityStatus;

                                db.Updateable(CntrItem).UpdateColumns(a => new { a.F_WEIGHT, a.S_BS_TYPE }).ExecuteCommand();
                            }
                            else
                            {
                                var cir = new CntrItemDetail
                                {
                                    S_CNTR_CODE = model.Rfid,
                                    S_ITEM_CODE = itemcode,
                                    S_ITEM_NAME = model.PartNumber,
                                    S_ITEM_SPEC = model.PartDesc,
                                    F_QTY = float.Parse(model.LotList[0].qty),
                                    S_BS_TYPE = "余料",
                                    F_WEIGHT = model.LotList[0].Weight.ToString(),
                                    S_ITEM_STATE = model.LotList[0].QualityStatus,
                                    D_EXP_DATE = model.LotList[0].MaturityTime,
                                    D_PRD_DATE = model.LotList[0].ProductionTime
                                };
                                db.Insertable<CntrItemDetail>(cir).ExecuteCommand();
                            }
                            LogHelper.Info("创建任务成功");
                        }
                        else
                        {
                            result.code = "1";
                            result.msg = $"库区:{areacode}无可用货位";
                            AddErrorInfo("查找货位失败", result.msg, Source);
                            result.msg = $"任务创建失败";
                            AddErrorInfo("任务创建失败", result.msg, Source);
                            return result;
                        }

                    }
                    else
                    {

                        result.code = "1";
                        result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
                        LogHelper.Info($"Putin==> {result.msg}");
                        AddErrorInfo("查找库区失败", result.msg, Source);
                        return result;
                    }

                }
                else
                {

                    result.code = "1";
                    result.msg = $"货位:{Start}找不到对应货位";
                    AddErrorInfo("查找货位失败", result.msg, Source);
                    return result;
                }

                #endregion

                #region 创建任务
                if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
                {
                    if (startloc.N_LOCK_STATE != 0)
                    {
                        result.code = "1";
                        result.msg = $"创建任务失败，起点{Start}有锁";
                        AddErrorInfo("货位有锁", result.msg);
                        return result;
                    }
                    //创建wcs任务
                    var wcsTask = new WCSTask
                    {
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_TYPE = "余料返回",
                        S_EQ_NO = model.TaskNumber,
                        S_START_LOC = Start,
                        S_END_LOC = End,
                        S_START_WH = startloc.S_WH_CODE,
                        S_START_AREA = startloc.S_AREA_CODE,
                        S_END_WH = loc.S_WH_CODE,
                        S_END_AREA = loc.S_AREA_CODE,
                        N_CNTR_COUNT = 1,
                        N_SCHEDULE_TYPE = 1,
                        S_CNTR_CODE = model.Rfid,
                        N_START_LAYER = 1,
                        N_END_LAYER = 1,
                        Z_TYPE = 5

                    };
                    LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
                    if (WCSHelper.CreateTask(wcsTask))
                    {
                        //LocationHelper.LockLoc(Start, 2);
                        //LocationHelper.LockLoc(End, 1);
                        //创建任务成功 更新余料信息
                        var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
                        if (CntrItem != null)
                        {
                            CntrItem.F_WEIGHT = model.LotList[0].Weight.ToString();
                            CntrItem.S_BS_TYPE = "余料";
                            CntrItem.F_QTY = float.Parse(model.LotList[0].qty);
                            CntrItem.S_ITEM_STATE = model.LotList[0].QualityStatus;

                            db.Updateable(CntrItem).UpdateColumns(a => new { a.F_WEIGHT, a.S_BS_TYPE }).ExecuteCommand();
                        }
                        LogHelper.Info("创建任务成功");
                    }
                    else
                    {
                        result.code = "1";
                        result.msg = $"任务创建失败";
                        AddErrorInfo("任务创建失败", result.msg, Source);
                        result.msg = "创建任务失败，未找到对应的取货点或卸货点";
                        return result;
                    }
                    #endregion
                }
                else
                {
                    result.code = "1";
                    result.msg = "创建任务失败，未找到对应的取货点或卸货点";
                    return result;
                }
                #endregion




                return result;
            }
@@ -2263,7 +2313,8 @@
            }

            return result;
        }  /// <summary>
        }
        /// <summary>
        /// 库位清空
        /// </summary>
        /// <param name="model"></param>
@@ -2286,42 +2337,48 @@
                var location = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == loc).First();
                if (location != null)
                {
                    var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).First();

                    if (loccntr != null)
                    var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).ToList();
                    if (loccntr.Count > 0)
                    {

                        string cntrcode = loccntr.S_CNTR_CODE;
                        var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
                        if (CntrItem != null)
                        foreach (var item in loccntr)
                        {

                            string cntrcode = item.S_CNTR_CODE;
                            LocationHelper.UnBindingLoc(loc, new List<string>() { cntrcode });
                            // db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
                            if (db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE == cntrcode).ExecuteCommand() > 0)
                            var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
                            if (CntrItem != null)
                            {
                                LogHelper.Info($"ClearLoc 库位清除成功");
                                db.Deleteable<Container>().Where(it => it.S_CODE == item.S_CNTR_CODE).ExecuteCommand();
                                // db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
                                if (db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE == cntrcode).ExecuteCommand() > 0)
                                {
                                    LogHelper.Info($"ClearLoc 库位清除成功");
                                }
                                else
                                {
                                    LogHelper.Info($"ClearLoc 库位清除失败");
                                    result.code = "1";
                                    result.msg = "库位清除失败";
                                    AddErrorInfo("库位清除失败", result.msg, Source);
                                    return result;
                                }
                            }
                            else
                            {
                                LogHelper.Info($"ClearLoc 库位清除失败");
                                result.code = "1";
                                result.msg = "库位清除失败";
                                AddErrorInfo("库位清除失败", result.msg, Source);
                                return result;
                                LogHelper.Info($"库区清空=》托盘:{cntrcode}无物料数据");

                            }

                        }
                        else
                        {
                            LogHelper.Info($"ClearLoc 托盘{cntrcode}无物料绑定关系");
                        }

                       
                    }
                    else
                    {
                        LogHelper.Info($"ClearLoc 货位{loc}无托盘货位绑定关系");
                        result.code = "1";
                        result.msg = $" ClearLoc 货位{loc}无托盘货位绑定关系";
                        AddErrorInfo("库位清除失败", result.msg, Source);
                        return result;

                    }

                }
                else
                {
@@ -2439,6 +2496,8 @@
        #endregion

        #region 合肥佳通业务方法

        
        /// <summary>
        /// 托盘入库算法 
        /// </summary>
@@ -2496,6 +2555,7 @@
            //}
            return result;
        }


        /// <summary>
        /// 根据物料计算托盘出库
@@ -2629,7 +2689,7 @@

            lock (_lockLocation)
            {
                var loc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == jtcode.Trim() && a.S_NOTE == cntrType && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0&&a.S_LOCK_STATE=="无").First();
                var loc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == jtcode.Trim() && a.S_NOTE == cntrType && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无").First();
                if (loc != null)
                {
                    End = loc;
@@ -2702,7 +2762,7 @@
                        Location other = null;
                        //当前排没有锁并且有空位置
                        //先找满位，然后后面一层要么是空，要么不存在
                        other = rowList.OrderBy(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 0).FirstOrDefault();
                        other = rowList.OrderBy(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0).FirstOrDefault();
                        //if (full == null)
                        //{
                        //    //没有满位，那就找最小的空位