1

wankeda

2026-03-16 d5538af4a0bbc5511990aceb3431fb1caa9bbc65

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/PartialTaskService_Inbound.cs

@@ -12,15 +12,1439 @@
using MailKit.Search;
using System.Reflection.Metadata;
using static WIDESEA_ITaskInfoService.ITaskService;
using static WIDESEA_Common.HouseInventoryIn;
using WIDESEA_Common;
using Parameter = WIDESEA_Common.Parameter;
using WIDESEA_Core.LogHelper;
using WIDESEA_DTO.Task;
using WIDESEA_Core.TaskEnum;
using WIDESEA_Model.Models.Inbound;
using WIDESEA_Common.OrderEnum;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService
    {


        /// <summary>
        /// ä»…申请任务，让WCS根据路由确定下一地址
        /// </summary>
        /// <param name="stationCode"></param>
        /// <param name="palletCode"></param>
        /// <returns></returns>
        public WebResponseContent DeviceRequestInboundTaskSimple(string stationCode, string palletCode, int heightType)
        {
            try
            {
                Dt_Task task = Repository.QueryFirst(x => x.PalletCode == palletCode);
                if (task != null)
                {
                    //PushTasksToWCS(new List<Dt_Task> { task });
                    return WebResponseContent.Instance.Error($"该托盘{palletCode}已生成任务");
                }
                Dt_StockInfo stockInfo = _stockRepository.StockInfoRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();

                if (stockInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到组盘信息");
                }
                if (stockInfo.StockStatus == StockStatusEmun.合托出库完成.ObjToInt())
                {

                }
                ///判断是否存在回库单,进行回原库位逻辑
                string returnOrderNo = stockInfo.Details?.Where(x => x.StockId == stockInfo.Id).FirstOrDefault()?.OrderNo;
                Dt_ReturnOrder returnOrder = _returnOrderRepository.QueryFirst(x => x.OrderNo == returnOrderNo && x.OrderStatus == InOrderStatusEnum.未开始.ObjToInt());
                Dt_RoadwayInfo returnRoadwayInfo = new Dt_RoadwayInfo();
                if (returnOrder != null && !string.IsNullOrEmpty(returnOrder.LocationCode))
                {
                    Dt_LocationInfo locationInfo1 = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == returnOrder.LocationCode);
                    if (locationInfo1 == null)
                    {
                        return WebResponseContent.Instance.Error($"回库单中该库位{returnOrder.LocationCode}未找到");
                    }
                    returnRoadwayInfo = _basicRepository.RoadwayInfoRepository.QueryFirst(x => x.RoadwayNo == locationInfo1.RoadwayNo);
                }

                if (Repository.QueryFirst(x => x.SourceAddress == (returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode) && x.TaskStatus == TaskStatusEnum.New.ObjToInt()) != null)
                {
                    return WebResponseContent.Instance.Error($"该站点已有未执行的任务");
                }

                var details = stockInfo.Details.FirstOrDefault();
                if (!string.IsNullOrEmpty(stockInfo.LocationCode))
                {
                    return WebResponseContent.Instance.Error($"该托盘已绑定货位");
                }
                Dt_RoadwayInfo roadwayInfo = _basicRepository.RoadwayInfoRepository.QueryFirst(x => x.InStationCode == (returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode));
                if (roadwayInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该入库站台地址");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == roadwayInfo.RoadwayNo);
                if (warehouse == null)
                {
                    return WebResponseContent.Instance.Error("未找到该仓库");
                }
                Dt_LocationInfo? locationInfo = new Dt_LocationInfo();
                if (returnOrder != null && !string.IsNullOrEmpty(returnOrder.LocationCode))
                {
                    locationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == returnOrder.LocationCode);
                    if (locationInfo.LocationStatus != LocationStatusEnum.Lock.ObjToInt() || locationInfo.EnableStatus == EnableStatusEnum.Disable.ObjToInt() || locationInfo.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt())
                    {
                        return WebResponseContent.Instance.Error($"该回库单货位{locationInfo.LocationCode}非锁定状态或货位启用状态不正确，请检查");
                    }
                }
                else
                {
                    locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayInfo.RoadwayNo, stockInfo.PalletType, warehouse.WarehouseId, "", heightType);//, stockInfo.WarehouseId
                    if (locationInfo == null)
                    {
                        return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
                    }
                }

                Dt_Task newTask = new Dt_Task()
                {
                    CurrentAddress = "",
                    Grade = 0,
                    NextAddress = returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode,
                    PalletCode = palletCode,
                    OrderNo = details.OrderNo,
                    Roadway = roadwayInfo.RoadwayNo,
                    SourceAddress = "",
                    TargetAddress = locationInfo.LocationCode,
                    TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    WarehouseId = stockInfo.WarehouseId,
                    PalletType = GetPalletType(warehouse, palletCode),//GetPalletType(warehouse, palletCode)
                    Creater = "WCS",
                    CreateDate = DateTime.Now
                };
                string MaterielCode = stockInfo.Details?.Where(x => x.StockId == stockInfo.Id).FirstOrDefault()?.MaterielCode;
                float Quantity = (float)stockInfo.Details?.Where(x => x.StockId == stockInfo.Id).Sum(x => x.StockQuantity);
                if (MaterielCode != null && Quantity != null)
                {
                    newTask.MaterielCode = MaterielCode;
                    newTask.Quantity = (float)Quantity;
                }
                if (stockInfo.StockStatus == StockStatusEmun.余料退库.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.SurplusReturn.ObjToInt();
                }
                if (stockInfo.StockStatus == StockStatusEmun.反拣入库.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.ReverseIn.ObjToInt();
                }
                if (stockInfo.StockStatus == StockStatusEmun.盘点库存完成.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.InInventory.ObjToInt();
                }
                //if (stockInfo.StockStatus == StockStatusEmun.手动组盘暂存.ObjToInt())
                //{
                //    stockInfo.StockStatus = StockStatusEmun.手动组盘入库确认.ObjToInt();
                //}
                //else if (stockInfo.StockStatus == StockStatusEmun.MES退库.ObjToInt())
                //{
                //    newTask.TaskType = TaskTypeEnum.MesMatReturn.ObjToInt();
                //}
                //else if (stockInfo.StockStatus == StockStatusEmun.MES空托退库.ObjToInt())
                //{
                //    Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.WarehouseId == stockInfo.WarehouseId && x.PalletType == stockInfo.PalletType);
                //    //todo å°æ‰˜ç›˜æš‚时未启用
                //    if (palletTypeInfo.LocaitonCount == 2)
                //    {
                //        newTask.TaskType = TaskTypeEnum.MesPalletLargeReturn.ObjToInt();
                //    }
                //    else
                //    {
                //        newTask.TaskType = TaskTypeEnum.MesPalletSmallReturn.ObjToInt();
                //    }
                //}
                //else
                //{
                stockInfo.StockStatus = StockStatusEmun.入库确认.ObjToInt();
                locationInfo.LocationStatus = LocationStatusEnum.Lock.ObjToInt();
                //}

                _unitOfWorkManage.BeginTran();
                int taskId = BaseDal.AddData(newTask);
                newTask.TaskId = taskId;
                if (returnOrder != null)
                {
                    returnOrder.OrderStatus = InOrderStatusEnum.入库中.ObjToInt();
                    _returnOrderRepository.UpdateData(returnOrder);
                }
                _stockRepository.StockInfoRepository.UpdateData(stockInfo);
                _locationInfoService.UpdateData(locationInfo);

                _unitOfWorkManage.CommitTran();
                WMSTaskDTO wMSTaskDTO = _mapper.Map<WMSTaskDTO>(newTask);
                if (warehouse.WarehouseCode.Contains("CP"))
                {
                    PushTasksWCS(new List<Dt_Task> { newTask });
                }
                else
                {
                    PushTasksToWCS(new List<Dt_Task> { newTask });
                }
                return WebResponseContent.Instance.OK(data: wMSTaskDTO);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public WebResponseContent CPDeviceRequestInboundTaskSimple(string stationCode, string palletCode, int heightType, string courceAddress)
        {
            try
            {
                Dt_Task task = Repository.QueryFirst(x => x.PalletCode == palletCode);
                if (task != null)
                {
                    return WebResponseContent.Instance.Error($"该托盘{palletCode}已生成任务");
                }
                Dt_StockInfo stockInfo = _stockRepository.StockInfoRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();

                if (stockInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到组盘信息");
                }

                Dt_RoadwayInfo returnRoadwayInfo = new Dt_RoadwayInfo();
                if (stockInfo.StockStatus == StockStatusEmun.合托出库完成.ObjToInt())
                {
                    Dt_LocationInfo locationInfo1 = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == stockInfo.LocationCode);
                    if (locationInfo1 == null)
                    {
                        return WebResponseContent.Instance.Error($"回库单中该库位{stockInfo.LocationCode}未找到");
                    }
                    returnRoadwayInfo = _basicRepository.RoadwayInfoRepository.QueryFirst(x => x.RoadwayNo == locationInfo1.RoadwayNo && x.InStationCode == (returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode));
                }
                ///判断是否存在回库单,进行回原库位逻辑
                string returnOrderNo = stockInfo.Details?.Where(x => x.StockId == stockInfo.Id).FirstOrDefault()?.OrderNo;
                Dt_ReturnOrder returnOrder = _returnOrderRepository.QueryFirst(x => (x.OrderNo == returnOrderNo || x.LPNNo == palletCode) && x.OrderStatus == InOrderStatusEnum.未开始.ObjToInt());
                if (returnOrder != null && !string.IsNullOrEmpty(returnOrder.LocationCode))
                {
                    Dt_LocationInfo locationInfo1 = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == returnOrder.LocationCode);
                    if (locationInfo1 == null)
                    {
                        return WebResponseContent.Instance.Error($"回库单中该库位{returnOrder.LocationCode}未找到");
                    }
                    returnRoadwayInfo = _basicRepository.RoadwayInfoRepository.QueryFirst(x => x.RoadwayNo == locationInfo1.RoadwayNo && x.InStationCode == (returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode));
                }

                if (Repository.QueryFirst(x => x.SourceAddress == (returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode) && x.TaskStatus == TaskStatusEnum.New.ObjToInt()) != null)
                {
                    return WebResponseContent.Instance.Error($"该站点已有未执行的任务");
                }

                var details = stockInfo.Details.FirstOrDefault();
                if (!string.IsNullOrEmpty(stockInfo.LocationCode))
                {
                    return WebResponseContent.Instance.Error($"该托盘已绑定货位");
                }
                Dt_RoadwayInfo roadwayInfo = _basicRepository.RoadwayInfoRepository.QueryFirst(x => x.InStationCode == (returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode));
                if (roadwayInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该入库站台地址");
                }

                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == roadwayInfo.RoadwayNo);
                if (warehouse == null)
                {
                    return WebResponseContent.Instance.Error("未找到该仓库");
                }

                Dt_LocationInfo? locationInfo = new Dt_LocationInfo();
                if (returnOrder != null && !string.IsNullOrEmpty(returnOrder.LocationCode))
                {
                    locationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == returnOrder.LocationCode);
                    if (locationInfo.LocationStatus != LocationStatusEnum.Lock.ObjToInt() || locationInfo.EnableStatus == EnableStatusEnum.Disable.ObjToInt() || locationInfo.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt())
                    {
                        return WebResponseContent.Instance.Error($"该回库单货位{locationInfo.LocationCode}非锁定状态或货位启用状态不正确，请检查");
                    }
                }
                else
                {
                    locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayInfo.RoadwayNo, stockInfo.PalletType, warehouse.WarehouseId, "", heightType);//, stockInfo.WarehouseId
                    if (locationInfo == null)
                    {
                        return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
                    }
                }
                Dt_Task newTask = new Dt_Task()
                {
                    CurrentAddress = courceAddress,
                    Grade = 0,
                    NextAddress = returnRoadwayInfo.InStationCode != null ? returnRoadwayInfo.InStationCode : stationCode,
                    PalletCode = palletCode,
                    OrderNo = details.OrderNo,
                    Roadway = roadwayInfo.RoadwayNo,
                    SourceAddress = courceAddress,
                    TargetAddress = locationInfo.LocationCode,
                    TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    WarehouseId = stockInfo.WarehouseId,
                    PalletType = GetPalletType(warehouse, palletCode),//GetPalletType(warehouse, palletCode)
                    Creater = "WCS",
                    CreateDate = DateTime.Now
                };
                string MaterielCode = stockInfo.Details?.Where(x => x.StockId == stockInfo.Id).FirstOrDefault()?.MaterielCode;
                float Quantity = (float)stockInfo.Details?.Where(x => x.StockId == stockInfo.Id).Sum(x => x.StockQuantity);
                if (MaterielCode != null && Quantity != null)
                {
                    newTask.MaterielCode = MaterielCode;
                    newTask.Quantity = (float)Quantity;
                }
                if (stockInfo.StockStatus == StockStatusEmun.余料退库.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.SurplusReturn.ObjToInt();
                }
                if (stockInfo.StockStatus == StockStatusEmun.反拣入库.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.ReverseIn.ObjToInt();
                }
                if (stockInfo.StockStatus == StockStatusEmun.盘点库存完成.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.InInventory.ObjToInt();
                }
                if (stockInfo.StockStatus == StockStatusEmun.合托出库完成.ObjToInt())
                {
                    newTask.TaskType = TaskTypeEnum.InSyncretism.ObjToInt();
                }
                //if (stockInfo.StockStatus == StockStatusEmun.手动组盘暂存.ObjToInt())
                //{
                //    stockInfo.StockStatus = StockStatusEmun.手动组盘入库确认.ObjToInt();
                //}
                //else if (stockInfo.StockStatus == StockStatusEmun.MES退库.ObjToInt())
                //{
                //    newTask.TaskType = TaskTypeEnum.MesMatReturn.ObjToInt();
                //}
                //else if (stockInfo.StockStatus == StockStatusEmun.MES空托退库.ObjToInt())
                //{
                //    Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.WarehouseId == stockInfo.WarehouseId && x.PalletType == stockInfo.PalletType);
                //    //todo å°æ‰˜ç›˜æš‚时未启用
                //    if (palletTypeInfo.LocaitonCount == 2)
                //    {
                //        newTask.TaskType = TaskTypeEnum.MesPalletLargeReturn.ObjToInt();
                //    }
                //    else
                //    {
                //        newTask.TaskType = TaskTypeEnum.MesPalletSmallReturn.ObjToInt();
                //    }
                //}
                //else
                //{
                else
                {
                    stockInfo.StockStatus = StockStatusEmun.入库确认.ObjToInt();
                }
                locationInfo.LocationStatus = LocationStatusEnum.Lock.ObjToInt();
                //}

                _unitOfWorkManage.BeginTran();
                int taskId = BaseDal.AddData(newTask);
                newTask.TaskId = taskId;
                if (returnOrder != null)
                {
                    returnOrder.OrderStatus = InOrderStatusEnum.入库中.ObjToInt();
                    _returnOrderRepository.UpdateData(returnOrder);
                }
                _stockRepository.StockInfoRepository.UpdateData(stockInfo);
                _locationInfoService.UpdateData(locationInfo);

                _unitOfWorkManage.CommitTran();
                WMSTaskDTO wMSTaskDTO = _mapper.Map<WMSTaskDTO>(newTask);

                PushTasksWCS(new List<Dt_Task> { newTask });

                return WebResponseContent.Instance.OK(data: wMSTaskDTO);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        /// <summary>
        /// è¿”回入库仓库
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ApplyLocation(string palletCode)
        {
            try
            {
                Dt_StockInfo stockInfo = _stockRepository.StockInfoRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();

                if (stockInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到组盘信息");
                }
                return WebResponseContent.Instance.OK(data: stockInfo.WarehouseId);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// å…¥åº“任务申请分配货位
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="roadwayNo">巷道号</param>
        /// <returns></returns>
        public WebResponseContent AssignInboundTaskLocation(int taskNum, string roadwayNo)
        {
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该入库任务");
                }

                if (_basicRepository.LocationInfoRepository.QueryFirst(x => x.LocationCode == task.TargetAddress) != null)
                {
                    return WebResponseContent.Instance.OK(data: task.TargetAddress);
                }

                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, task.PalletType);//, task.WarehouseId
                if (locationInfo == null)
                {
                    return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
                }

                task.Roadway = roadwayNo;
                task.TargetAddress = locationInfo.LocationCode;

                task.TaskStatus = TaskStatusEnum.SC_Execute.ObjToInt();



                LocationStatusEnum lastStatus = (LocationStatusEnum)locationInfo.LocationStatus;

                _unitOfWorkManage.BeginTran();
                //_recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, lastStatus, LocationStatusEnum.Lock, LocationChangeType.InboundAssignLocation);
                //_basicService.LocationInfoService.UpdateLocationStatus(locationInfo, task.PalletType, LocationStatusEnum.Lock, task.WarehouseId);
                BaseDal.UpdateData(task);
                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK(data: locationInfo.LocationCode);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        /// <summary>
        /// ç«‹åº“入库指令上传
        /// </summary>
        /// <param name="stationCode">起始地址</param>
        /// <param name="palletCode">托盘编号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent InboundRequest(string stationCode, string roadwayNo, string palletCode)
        {
            // è¾“入验证
            if (string.IsNullOrWhiteSpace(palletCode))
                return WebResponseContent.Instance.Error("请输入正确托盘号");

            try
            {
                Dt_Task task = Repository.QueryFirst(x => x.PalletCode == palletCode);
                if (task != null)
                {
                    return WebResponseContent.Instance.Error($"该托盘{palletCode}已生成任务");
                }
                // èŽ·å–入库单明细
                var inboundOrderDet = GetInboundOrderDetail(palletCode);
                if (inboundOrderDet == null)
                    return WebResponseContent.Instance.Error($"未找到托盘号 {palletCode} å¯¹åº”的入库单明细");

                // èŽ·å–入库单
                var inboundOrder = GetInboundOrder(inboundOrderDet.OrderId);
                if (inboundOrder == null)
                    return WebResponseContent.Instance.Error($"未找到入库单信息");

                // éªŒè¯å…¥åº“单明细
                if (inboundOrder.Details == null || inboundOrder.Details.Count == 0)
                    return WebResponseContent.Instance.Error($"入库单 {inboundOrder.OrderNo} æ²¡æœ‰æ˜Žç»†ä¿¡æ¯");

                // èŽ·å–仓库和巷道信息
                var warehouse = GetWarehouse(inboundOrder.WarehouseId);
                var roadwayInfo = GetRoadwayInfo(warehouse.WarehouseCode);

                var dt_Stock = _stockRepository.StockInfoRepository.QueryFirst(x => x.PalletCode == palletCode);
                // æ£€æŸ¥å…¥åº“请求
                var checkResult = CheckRequestInbound(roadwayInfo.InSCStationCode, palletCode, true, dt_Stock);
                if (!checkResult.Item1)
                    return WebResponseContent.Instance.Error(checkResult.Item2);

                // åˆ†é…åº“位并更新数据
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, dt_Stock.PalletType, dt_Stock.WarehouseId);//
                //Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(stationCode, TaskTypeEnum.Inbound.ObjToInt());
                if (locationInfo == null)
                {
                    return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
                }

                Dt_Task newTask = new Dt_Task()
                {
                    CurrentAddress = "",
                    Grade = 0,
                    NextAddress = stationCode,
                    PalletCode = palletCode,
                    Roadway = roadwayNo,
                    SourceAddress = "",
                    TargetAddress = locationInfo.LocationCode,
                    TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    WarehouseId = dt_Stock.WarehouseId,
                    PalletType = dt_Stock.PalletType,
                    Creater = "WMS",
                    CreateDate = DateTime.Now,
                };

                LocationStatusEnum lastStatus = (LocationStatusEnum)locationInfo.LocationStatus;
                _unitOfWorkManage.BeginTran();
                Db.InsertNav(dt_Stock).Include(x => x.Details).ExecuteCommand();
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, lastStatus.ObjToInt(), LocationStatusEnum.Lock.ObjToInt(), LocationChangeType.InboundAssignLocation.ObjToInt());
                //_basicService.LocationInfoService.UpdateLocationStatus(locationInfo, newTask.PalletType, LocationStatusEnum.Lock, newTask.WarehouseId);
                int taskId = BaseDal.AddData(newTask);
                newTask.TaskId = taskId;
                _stockRepository.StockInfoRepository.UpdateData(dt_Stock);
                _unitOfWorkManage.CommitTran();
                WMSTaskDTO wMSTaskDTO = _mapper.Map<WMSTaskDTO>(newTask);

                PushTasksToWCS(new List<Dt_Task> { newTask });
                if (newTask.WarehouseId == 5) PutFinish(stationCode);
                return WebResponseContent.Instance.OK(data: wMSTaskDTO);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        private Dt_InboundOrderDetail GetInboundOrderDetail(string palletCode)
        {
            return BaseDal.Db.Queryable<Dt_InboundOrderDetail>()
                .Where(x => x.LPNNo == palletCode)
                .First();
        }

        private Dt_InboundOrder GetInboundOrder(int orderId)
        {
            return BaseDal.Db.Queryable<Dt_InboundOrder>()
                .Where(x => x.Id == orderId)
                .Includes(x => x.Details)
                .First();
        }

        private Dt_Warehouse GetWarehouse(int warehouseId)
        {
            return _basicService.WarehouseService.Repository
                .QueryFirst(x => x.WarehouseId == warehouseId);
        }

        private Dt_RoadwayInfo GetRoadwayInfo(string warehouseCode)
        {
            return _basicService.RoadwayInfoService.Repository
                .QueryFirst(x => x.RoadwayNo == warehouseCode);
        }

        private Dt_StockInfo GetOrCreateStockInfo(string palletCode, Dt_InboundOrder inboundOrder, Dt_InboundOrderDetail inboundOrderDet, Dt_Warehouse warehouse)
        {
            var stockInfo = BaseDal.Db.Queryable<Dt_StockInfo>()
                .Where(x => x.PalletCode == palletCode)
                .Includes(x => x.Details)
                .First();
            decimal beforeQuantity = 0;
            if (stockInfo == null)
            {
                stockInfo = CreateNewStockInfo(palletCode, inboundOrder, inboundOrderDet, warehouse);
                //CreateStockInfoDetail(stockInfo, inboundOrder, inboundOrderDet);
            }
            else
            {
                if (stockInfo.StockStatus != StockStatusEmun.组盘暂存.ObjToInt())
                {
                    return null;
                }
                beforeQuantity = stockInfo.Details.Sum(x => x.StockQuantity);
            }

            return stockInfo;
        }

        private Dt_StockInfo CreateNewStockInfo(string palletCode, Dt_InboundOrder inboundOrder, Dt_InboundOrderDetail inboundOrderDet, Dt_Warehouse warehouse)
        {
            var dt_StockInfoDetail = new Dt_StockInfoDetail
            {
                //StockId = stockInfo.Id,
                MaterielCode = inboundOrderDet.MaterielCode,
                MaterielName = inboundOrderDet.MaterielName,
                OrderNo = inboundOrder.OrderNo,
                BatchNo = inboundOrderDet.BatchNo,
                LinId = inboundOrderDet.LinId,
                StockQuantity = inboundOrderDet.OrderQuantity,
                Status = (int)StockStatusEmun.组盘暂存,
                Creater = "WMS",
                CreateDate = DateTime.Now,
                Id = inboundOrderDet.LinId.ObjToInt(),
            };

            var dt_Stock = new Dt_StockInfo
            {
                BatchNo = inboundOrderDet.BatchNo,
                PalletCode = palletCode,
                PalletType = GetPalletType(warehouse, palletCode),
                IsFull = true,
                StockStatus = (int)StockStatusEmun.组盘暂存,
                Creater = "WMS",
                CreateDate = DateTime.Now,
                MaterialType = (int)InventoryMaterialType.成品,
                Materialweight = 0,
                Wlstatus = (int)InventoryMaterialStatus.合格,
                Mgeneratetime = DateTime.Now,
                WarehouseId = warehouse.WarehouseId,
                Details = new List<Dt_StockInfoDetail> { dt_StockInfoDetail }
            };

            //_stockService.StockInfoService.Repository.AddData(dt_Stock);
            Db.InsertNav(dt_Stock).Include(x => x.Details).ExecuteCommand();
            return _stockService.StockInfoService.Repository.GetStockInfo(palletCode);
        }

        private void CreateStockInfoDetail(Dt_StockInfo stockInfo, Dt_InboundOrder inboundOrder, Dt_InboundOrderDetail inboundOrderDet)
        {
            var dt_StockInfoDetail = new Dt_StockInfoDetail
            {
                StockId = stockInfo.Id,
                MaterielCode = inboundOrderDet.MaterielCode,
                MaterielName = inboundOrderDet.MaterielName,
                OrderNo = inboundOrder.OrderNo,
                BatchNo = inboundOrderDet.BatchNo,
                LinId = inboundOrderDet.LinId,
                StockQuantity = inboundOrderDet.OrderQuantity,
                Status = (int)StockStatusEmun.组盘暂存,
                Creater = "WMS",
                CreateDate = DateTime.Now,
                Id = inboundOrderDet.LinId.ObjToInt(),
            };

            _stockService.StockInfoDetailService.Repository.AddData(dt_StockInfoDetail);
        }

        //查询仓库托盘货物类型
        public int GetPalletType(Dt_Warehouse warehouse, string palletCode)
        {
            if (warehouse.WarehouseCode.Contains("BC"))
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 3));
                if (palletTypeInfo == null)
                {
                    throw new Exception($"托盘号错误");
                }
                return palletTypeInfo.PalletType;
            }
            else 
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 2));
                if (palletTypeInfo == null)
                {
                    throw new Exception($"托盘号错误");
                }
                return palletTypeInfo.PalletType;
            }
            return 0;
        }




        #region
        //public WebResponseContent InboundRequest(SaveModel saveModel)
        //{
        //    string palletCode = saveModel.palletCode;
        //    if (saveModel.palletCode == null) return WebResponseContent.Instance.Error($"请输入正确托盘号");
        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {
        //        Dt_InboundOrderDetail inboundOrderDet = BaseDal.Db.Queryable<Dt_InboundOrderDetail>().Where(x => x.LPNNo == palletCode).First();
        //        Dt_InboundOrder inboundOrder = BaseDal.Db.Queryable<Dt_InboundOrder>().Where(x => x.Id == inboundOrderDet.OrderId).Includes(x => x.Details).First();
        //        if (inboundOrder == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到入库单信息");
        //        }
        //        Dt_Warehouse warehouse = _basicService.WarehouseService.Repository.QueryFirst(x => x.WarehouseId == inboundOrder.WarehouseId);
        //        Dt_RoadwayInfo roadwayInfo = _basicService.RoadwayInfoService.Repository.QueryFirst(x => x.RoadwayNo == warehouse.WarehouseCode);
        //        if (roadwayInfo != null) { }

        //        if (inboundOrder.Details == null || inboundOrder.Details.Count <= 0)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到入库单明细信息");
        //        }
        //        Dt_StockInfo stockInfo1 = BaseDal.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();
        //        if (stockInfo1 == null)
        //        {
        //            Dt_StockInfo dt_Stock = new()
        //            {
        //                BatchNo = inboundOrderDet.BatchNo,
        //                PalletCode = palletCode,
        //                IsFull = true,
        //                StockStatus = (int)StockStatusEmun.组盘暂存,
        //                Creater = "WMS",
        //                CreateDate = DateTime.Now,
        //                MaterialType = (int)InventoryMaterialType.成品,
        //                Materialweight = 0,
        //                Wlstatus = (int)InventoryMaterialStatus.合格,
        //                Mgeneratetime = DateTime.Now,
        //            };
        //            _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.GetStockInfo(palletCode);
        //            Dt_StockInfoDetail dt_StockInfoDetail = new()
        //            {
        //                StockId = dt_StockInfo.Id,
        //                MaterielCode = inboundOrderDet.MaterielCode,    //物料号
        //                MaterielName = inboundOrderDet.MaterielName,    //物料名称
        //                OrderNo = inboundOrder.OrderNo,        //物料详情
        //                BatchNo = inboundOrderDet.BatchNo,         //物料批次
        //                LinId = inboundOrderDet.LinId,                    //SerialNumber = targetCodes[2].ToString(),    //包号
        //                                                                  //BatchNoName = dt_Int.OrderNo,
        //                StockQuantity = inboundOrderDet.OrderQuantity,    //重量
        //                                                                  //OutboundQuantity = 1,    //序列号
        //                Status = (int)StockStatusEmun.组盘暂存,
        //                Creater = "WMS",
        //                CreateDate = DateTime.Now,
        //                Id = inboundOrderDet.LinId.ObjToInt(),
        //            };
        //            _stockService.StockInfoDetailService.Repository.AddData(dt_StockInfoDetail);
        //        }
        //        Dt_StockInfo stockInfo = BaseDal.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();
        //        (bool, string) result = CheckRequestInbound(roadwayInfo.InSCStationCode, palletCode, true, stockInfo);
        //        if (!result.Item1) return content = WebResponseContent.Instance.Error(result.Item2);
        //        content = AssignLocUpdateData(roadwayInfo.InSCStationCode, TaskTypeEnum.Inbound.ObjToInt(), palletCode, true, stockInfo, inboundOrder.OrderNo);
        //    }
        //    catch (Exception ex)
        //    {
        //        content = WebResponseContent.Instance.Error(ex.Message);
        //    }
        //    return content;
        //}
        #endregion
        public string ReceiveWMSInventoryIn = WIDESEA_Core.Helper.AppSettings.Configuration["ReceiveWMSInventoryIn"];
        /// <summary>
        /// ç›˜ç‚¹å·®å¼‚数量回传
        /// </summary>
        /// <returns></returns>
        public WebResponseContent InventoryIn(string name, int qty)
        {
            WebResponseContent content = new();
            try
            {
                Dt_StockInfo stockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == name);
                Dt_StockInfoDetail stockInfoDetail = _stockService.StockInfoDetailService.Repository.QueryFirst(x => x.StockId == stockInfo.Id);
                Dt_OutboundOrderDetail outboundOrderDetail = _outboundService.OutboundOrderDetailService.Repository.QueryFirst(x => x.LPNNo == stockInfo.PalletCode);
                Dt_OutboundOrder outboundOrder = _outboundService.OutboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetail.OrderId);
                HouseInventoryIn houseInboundPassBack = new HouseInventoryIn();
                houseInboundPassBack.ApiType = "StockCountController";
                houseInboundPassBack.Method = "AsrsFinishedStockCount";

                data data = new data();
                data.InventoryIn data1 = new data.InventoryIn();
                data1.No = outboundOrder.OrderNo;
                data.InventoryIn.Inbound inbound = new data.InventoryIn.Inbound();
                inbound.LinId = outboundOrderDetail.LinId;
                inbound.LPN_No = outboundOrderDetail.LPNNo;
                inbound.MaterielCode = outboundOrderDetail.MaterielCode;
                inbound.OrderQuantity = outboundOrderDetail.OrderQuantity;
                inbound.BatchNo = outboundOrderDetail.BatchNo;
                inbound.FinishQty = qty;
                inbound.WarehouseCode = outboundOrderDetail.WarehouseCode;
                inbound.StorageAreaCode = outboundOrderDetail.StorageAreaCode;
                inbound.StorageLocationCode = outboundOrderDetail.StorageLocationCode;
                data1.DetailList.Add(inbound);
                data.Value.Add(data1);
                houseInboundPassBack.Parameters.Add(data);
                Authentication authentication = new Authentication()
                {
                    ApiType = "AuthenticationController",
                    Parameters = new List<Parameter>
                {
                     new Parameter { Value = "LKAdmin"},
                     new Parameter { Value = "LKAdmin"},
                },
                    Method = "Login",
                };
                var responses1 = HttpHelper.Post<WebResponseContent>(ReceiveWMSTaskAUT, authentication, "登录WMS账号");
                var Ticket = responses1.Context["Ticket"].ToString();
                var InvOrgId = responses1.Context["InvOrgId"].ToString();
                if (Ticket != null)
                {
                    houseInboundPassBack.Context = new Dictionary<string, string>();
                    houseInboundPassBack.Context.Add("Ticket", Ticket);
                    houseInboundPassBack.Context.Add("InvOrgId", InvOrgId);
                    var responses = HttpHelper.Post<WebResponseContent>(ReceiveWMSInventoryIn, houseInboundPassBack, "立库入库数量回传WMS");
                }
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            finally
            {

            }
            return content;
        }

        /// <summary>
        /// å…¥åº“分配货位及处理数据
        /// </summary>
        /// <param name="stationCode">起始地址</param>
        /// <param name="taskType">任务类型</param>
        /// <param name="palletCode">托盘编号</param>
        /// <param name="isUpdateStock">是否更新组盘信息--区分物料入库和空托入库</param>
        /// <param name="stockInfo">组盘信息--可空</param>
        /// <param name="orderNo">订单号--可空</param>
        /// <returns>返回处理结果</returns>
        private WebResponseContent AssignLocUpdateData(string stationCode, int taskType, string palletCode, bool isUpdateStock = true, Dt_StockInfo? stockInfo = null,
            string orderNo = "")
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_InboundOrder dt_Int = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.OrderNo == orderNo);
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(stationCode, taskType);
                //Dt_LocationInfo dt_LocationInfo = null;
                if (locationInfo != null)
                {
                    Dt_Task task = new()
                    {
                        CurrentAddress = "0",
                        Grade = 0,
                        PalletCode = palletCode,
                        NextAddress = "0",
                        Roadway = locationInfo.RoadwayNo,
                        SourceAddress = stationCode,
                        TargetAddress = locationInfo.LocationCode,
                        TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
                        TaskType = taskType,
                        OrderNo = orderNo,
                        CreateDate = DateTime.Now,
                        Creater = "WMS"
                    };
                    BaseDal.AddData(task);
                    int beforeStatus = locationInfo.LocationStatus;
                    if (isUpdateStock)
                    {
                        locationInfo.LocationStatus = LocationStatusEnum.Lock.ObjToInt();
                        _basicService.LocationInfoService.UpdateLocationLock(locationInfo, task.TaskNum, StockChangeType.Inbound.ObjToInt(), false);

                        if (stockInfo != null && stockInfo.Details != null && stockInfo.Details.Count > 0)
                        {
                            orderNo = stockInfo.Details.FirstOrDefault()?.OrderNo ?? "";

                            stockInfo.StockStatus = StockStatusEmun.入库确认.ObjToInt();
                            //stockInfo.LocationCode = task.TargetAddress;
                            _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                        }
                        else
                        {
                            return content = WebResponseContent.Instance.Error("未找到库存信息");
                        }
                    }
                    else
                    {
                        locationInfo.LocationStatus = LocationStatusEnum.Lock.ObjToInt();
                        _basicService.LocationInfoService.UpdateLocationLock(locationInfo, task.TaskNum, StockChangeType.Inbound.ObjToInt(), false);
                    }
                    //下发入库任务至WCS
                    //var responses = HttpHelper.Post<WebResponseContent>(ReceiveWMSTask, task, "下发任务入库");
                    dt_Int.OrderStatus = InboundStatusEnum.入库中.ObjToInt();
                    _inboundService.InbounOrderService.Repository.UpdateData(dt_Int);
                    _basicService.LocationInfoService.Repository.UpdateData(locationInfo);
                    _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, beforeStatus, StockChangeType.Inbound.ObjToInt(), orderNo, task.TaskNum);
                    return content = WebResponseContent.Instance.OK(data: task);
                }
                return content = WebResponseContent.Instance.Error("未找到可分配货位");
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }

        /// <summary>
        /// éªŒè¯æ•°æ®
        /// </summary>
        /// <param name="stationCode">起始地址</param>
        /// <param name="palletCode">托盘编号</param>
        /// <param name="isCheckStock">是否检查组盘信息--区分物料入库和空托入库</param>
        /// <param name="stockInfo">组盘信息--可空</param>
        /// <returns>返回处理结果</returns>
        private (bool, string) CheckRequestInbound(string stationCode, string palletCode, bool isCheckStock = true, Dt_StockInfo? stockInfo = null)
        {
            if (BaseDal.QueryFirst(x => x.PalletCode == palletCode) != null)
            {
                return (false, "该托盘号已有任务");
            }
            if (BaseDal.QueryFirst(x => (x.SourceAddress == stationCode || x.CurrentAddress == stationCode) && x.TaskStatus == InTaskStatusEnum.InNew.ObjToInt()) != null)
            {
                return (false, "当前入库站台已有一条新建任务");
            }
            if (isCheckStock)
            {
                if (stockInfo == null)
                {
                    return (false, "未找到组盘信息");
                }
                if (stockInfo.StockStatus != StockStatusEmun.组盘暂存.ObjToInt())
                {
                    return (false, "该组盘状态不可入库");
                }
                if (!string.IsNullOrEmpty(stockInfo.LocationCode))
                {
                    return (false, "该托盘已绑定货位");
                }
                if (stockInfo.Details == null || stockInfo.Details.Count == 0)
                {
                    return (false, "没有库存明细信息");
                }
            }
            else
            {
                if (_stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == palletCode) != null)
                {
                    return (false, "该托盘已存在库内");
                }
            }

            return (true, "成功");
        }


        /// <summary>
        /// æ ¹æ®æ‰˜ç›˜æ¡ç ï¼Œèµ·ç‚¹ä½ç½®ï¼Œç”Ÿæˆå…¥åº“信息
        /// </summary>
        /// <param name="PalletCode"></param>
        /// <returns></returns>
        //public WebResponseContent GenerateInventoryInformation(GenerateInv generate)
        //{

        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {
        //        Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //        if (task != null)
        //        {
        //            return content = WebResponseContent.Instance.Error($"已有该托盘的入库任务，托盘号：{task.PalletCode}");
        //        }
        //        else
        //        {

        //            //if ((generate.SourceAddress == "R01-003-041-011-01" || generate.SourceAddress == "R01-002-043-001-01" || generate.SourceAddress == "R02-003-027-011-01"))
        //            //{
        //            Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //            if (dt_StockInfo2 == null)
        //            {
        //                Dt_StockInfo dt_Stock = new()
        //                {
        //                    PalletCode = generate.PalletCode,
        //                    IsFull = true,
        //                    StockStatus = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                    MaterialType = (int)InventoryMaterialType.空托,
        //                    Materialweight = 0,
        //                    Wlstatus = (int)InventoryMaterialStatus.空托,
        //                    Mgeneratetime = DateTime.Now,
        //                };
        //                _stockService.StockInfoService.Repository.AddData(dt_Stock);
        //            }
        //            //}
        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode && x.StockStatus == (int)StockStatusEmun.组盘暂存);
        //            if (dt_StockInfo != null)
        //            {
        //                Dt_LocationInfo newLocation;
        //                Dt_LocationInfo newSourceAddress;
        //                newSourceAddress = _basicService.LocationInfoService.GetLocationplatform(generate.SourceAddress);
        //                int Locationtype = 1;   //默认为9
        //                if (dt_StockInfo.MaterialType == (int)InventoryMaterialType.成品 || (generate.SourceAddress == "R01-003-041-001-01" && dt_StockInfo.MaterialType == (int)InventoryMaterialType.原材料))
        //                {
        //                    Locationtype = 11;

        //                }
        //                else if (dt_StockInfo.MaterialType == (int)InventoryMaterialType.原材料)
        //                {
        //                    Locationtype = 10;
        //                }

        //                if (dt_StockInfo.MaterialType == (int)InventoryMaterialType.成品)
        //                {
        //                    string[] targetCodes = dt_StockInfo.PalletCode.Split("*");
        //                    Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.OrderName == targetCodes[0]);
        //                    if (dt_Inbound.Startingcolumn != 0 || dt_Inbound.Terminationcolumn != 0)
        //                    {
        //                        newLocation = _basicService.LocationInfoService.GetLocation2(newSourceAddress.RoadwayNo, Locationtype, dt_Inbound.Startingcolumn, dt_Inbound.Terminationcolumn);
        //                    }
        //                    else
        //                    {
        //                        newLocation = _basicService.LocationInfoService.GetLocation(newSourceAddress.RoadwayNo, Locationtype);
        //                    }

        //                }
        //                else
        //                {
        //                    newLocation = _basicService.LocationInfoService.GetLocation(newSourceAddress.RoadwayNo, Locationtype);
        //                }


        //                //string[] Pallet = PalletCode.Split("-");
        //                if (newLocation != null && newSourceAddress != null)
        //                {
        //                    //生成入库任务
        //                    Dt_Task dt_Task = new()
        //                    {
        //                        PalletCode = generate.PalletCode,
        //                        TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
        //                        Roadway = newLocation.RoadwayNo,
        //                        TaskType = TaskTypeEnum.Inbound.ObjToInt(),
        //                        TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
        //                        SourceAddress = newSourceAddress.LocationCode,
        //                        TargetAddress = newLocation.LocationCode,
        //                        CurrentAddress = newSourceAddress.LocationCode,
        //                        NextAddress = newLocation.LocationCode,
        //                        Grade = 1,
        //                        Creater = "WMS",
        //                        Depth = newLocation.Depth,
        //                        CreateDate = DateTime.Now,
        //                        MaterialType = dt_StockInfo.MaterialType
        //                    };
        //                    _unitOfWorkManage.BeginTran();
        //                    if (newLocation.LocationStatus == LocationStatusEnum.Free.ObjToInt())
        //                    {
        //                        newLocation.LocationStatus = newSourceAddress.LocationType == (int)LocationTypeEnum.EmptyOut ? LocationStatusEnum.PalletLock.ObjToInt() : LocationStatusEnum.Lock.ObjToInt();
        //                    }
        //                    BaseDal.AddData(dt_Task);
        //                    _basicService.LocationInfoService.UpdateData(newLocation);

        //                    _unitOfWorkManage.CommitTran();

        //                    return content = WebResponseContent.Instance.OK(data: dt_Task);
        //                }
        //                else
        //                {
        //                    return content = WebResponseContent.Instance.Error($"未找到对应的起点:{generate.SourceAddress},或终点{newSourceAddress.RoadwayNo}，信息");
        //                }

        //            }
        //            else
        //            {
        //                //Queryinventory(generate.PalletCode);
        //                return content = WebResponseContent.Instance.Error($"组盘，请核对托盘号:{generate.PalletCode}");
        //            }

        //        }

        //    }
        //    catch (Exception ex)
        //    {
        //        return content = WebResponseContent.Instance.Error($"生成入库任务出错，出错信息:{ex.Message}");
        //        throw;
        //    }
        //}

        ///// <summary>
        ///// æŸ¥è¯¢1巷道库存，是否运行进行入库  //带后续重新拼接
        ///// </summary>
        ///// <returns></returns>
        //public WebResponseContent Queryinventory3(GenerateInv generate)
        //{
        //    try
        //    {
        //        WebResponseContent content = new WebResponseContent();
        //        string result = generate.PalletCode.Substring(0, 2);
        //        Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.UpperOrderNo == result);
        //        Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //        if (dt_Inbound != null)
        //        {
        //            if (dt_StockInfo == null)
        //            {
        //                Dt_StockInfo dt_Stock = new()
        //                {
        //                    PalletCode = generate.PalletCode,
        //                    IsFull = true,
        //                    StockStatus = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                    MaterialType = (int)InventoryMaterialType.原材料,
        //                    Materialweight = 0,
        //                };
        //                _unitOfWorkManage.BeginTran();
        //                _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //                string part2 = generate.PalletCode.Substring(2, 8);

        //                string part3 = generate.PalletCode.Split('#')[1];
        //                Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                {
        //                    StockId = dt_StockInfo2.Id,
        //                    MaterielCode = result,    //物料编号
        //                    MaterielName = dt_Inbound.OrderNo,    //材质
        //                    OrderNo = generate.PalletCode,        //单据（托盘条码）
        //                    BatchNo = part2,         //批次号
        //                    SerialNumber = part3,    //序列号
        //                    StockQuantity = 1,    //序列号
        //                    OutboundQuantity = 1,    //序列号
        //                    Status = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                };
        //                _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);

        //                _unitOfWorkManage.CommitTran();
        //                return content = WebResponseContent.Instance.OK();
        //            }
        //            else
        //            {
        //                return content = WebResponseContent.Instance.OK();
        //            }

        //        }
        //        else
        //        {
        //            return content = WebResponseContent.Instance.Error("未找到该类型的解析");
        //        }

        //    }
        //    catch (Exception ex)
        //    {

        //        throw;
        //    }
        //}

        ///// <summary>
        ///// è§£æžåº“å­˜
        ///// </summary>
        ///// <returns></returns>
        //public WebResponseContent Queryinventory(GenerateInv generate)
        //{
        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {

        //        string[] targetCodes = generate.PalletCode.Split("*");
        //        if (targetCodes.Length == 4)
        //        {
        //            Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.OrderName == targetCodes[0]);

        //            if (dt_Inbound != null)
        //            {
        //                Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                if (dt_Inbound.OrderType == (int)InventoryMaterialType.原材料)   //0为原材料编码
        //                {
        //                    List<Dt_LocationInfo> locationInfos = _basicService.LocationInfoService.Repository.QueryData(x => x.RoadwayNo == "2" && x.LocationStatus == (int)LocationStatusEnum.Free && x.Depth == 1 && x.EnableStatus == (int)EnableStatusEnum.Normal && x.LocationType == (int)LocationTypeEnum.MaterialsCube);

        //                    if (dt_StockInfo == null)
        //                    {
        //                        Dt_StockInfo dt_Stock = new()
        //                        {
        //                            PalletCode = generate.PalletCode,
        //                            IsFull = true,
        //                            StockStatus = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,
        //                            MaterialType = (int)InventoryMaterialType.原材料,
        //                            Materialweight = decimal.Parse(targetCodes[3]),
        //                            Wlstatus = (int)InventoryMaterialStatus.待检,
        //                            Mgeneratetime = DateTime.Now,
        //                        };
        //                        _unitOfWorkManage.BeginTran();
        //                        _stockService.StockInfoService.Repository.AddData(dt_Stock);
        //                        Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                        string part2 = targetCodes[1].Substring(0, 2);  //解析物料批次找详情
        //                        Dt_InboundOrder dt_Int = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.UpperOrderNo == part2);

        //                        Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                        {
        //                            StockId = dt_StockInfo2.Id,
        //                            MaterielCode = dt_Inbound.OrderName,    //物料号
        //                            MaterielName = dt_Inbound.UpperOrderNo,    //物料名称
        //                            OrderNo = dt_Inbound.OrderNo,        //物料详情
        //                            BatchNo = targetCodes[1].ToString(),         //物料批次
        //                            SerialNumber = targetCodes[2].ToString(),    //包号
        //                            BatchNoName = dt_Int.OrderNo,
        //                            //StockQuantity = decimal.Parse(targetCodes[3].ToString()),    //重量
        //                            OutboundQuantity = 1,    //序列号
        //                            Status = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,

        //                        };
        //                        _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);
        //                        _unitOfWorkManage.CommitTran();
        //                        if (locationInfos.Count < 50)
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 1);
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 3);
        //                        }
        //                    }
        //                    else
        //                    {
        //                        if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                        {
        //                            if (locationInfos.Count < 50)
        //                            {
        //                                return content = WebResponseContent.Instance.OK(data: 1);
        //                            }
        //                            else
        //                            {
        //                                return content = WebResponseContent.Instance.OK(data: 3);
        //                            }
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                        }

        //                    }
        //                }
        //                else if (dt_Inbound.OrderType == (int)InventoryMaterialType.成品)
        //                {
        //                    if (dt_StockInfo == null)
        //                    {
        //                        Dt_StockInfo dt_Stock = new()
        //                        {
        //                            PalletCode = generate.PalletCode,
        //                            IsFull = true,
        //                            StockStatus = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,
        //                            MaterialType = (int)InventoryMaterialType.成品,
        //                            Materialweight = decimal.Parse(targetCodes[3]),
        //                            Wlstatus = (int)InventoryMaterialStatus.待检,
        //                            Mgeneratetime = DateTime.Now,
        //                        };
        //                        _unitOfWorkManage.BeginTran();
        //                        _stockService.StockInfoService.Repository.AddData(dt_Stock);
        //                        Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                        Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                        {
        //                            StockId = dt_StockInfo2.Id,
        //                            MaterielCode = dt_Inbound.OrderName,    //物料号
        //                            MaterielName = dt_Inbound.UpperOrderNo,    //物料名称
        //                            OrderNo = dt_Inbound.OrderNo,        //物料详情
        //                            BatchNo = targetCodes[1].ToString(),         //物料批次
        //                            BatchNoName = "",
        //                            SerialNumber = targetCodes[2],    //包号
        //                            //StockQuantity = decimal.Parse(targetCodes[3]),    //重量
        //                            OutboundQuantity = 1,    //序列号
        //                            Status = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,
        //                        };
        //                        _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);
        //                        _unitOfWorkManage.CommitTran();
        //                        return content = WebResponseContent.Instance.OK(data: 1);
        //                    }
        //                    else
        //                    {
        //                        if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 1);
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                        }
        //                    }
        //                }
        //                else
        //                {
        //                    return content = WebResponseContent.Instance.Error($"未找到条码解析，条码信息：{generate.PalletCode}");
        //                }
        //            }
        //            else
        //            {
        //                return content = WebResponseContent.Instance.Error($"未找到入库单，条码信息：{generate.PalletCode}");
        //            }

        //        }
        //        else
        //        {
        //            return content = WebResponseContent.Instance.Error($"解析的托盘条码长度不足4,条码信息：{generate.PalletCode}");
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        return content = WebResponseContent.Instance.Error($"系统巷道入库接口解析错误：错误：{ex.Message}");
        //        throw;
        //    }
        //}

        //public WebResponseContent Queryinventory2(GenerateInv generate)
        //{
        //    try
        //    {
        //        WebResponseContent content = new WebResponseContent();
        //        string result = generate.PalletCode.Substring(0, 2);
        //        if (result == "B-")
        //        {
        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //            if (dt_StockInfo == null)
        //            {
        //                Dt_StockInfo dt_Stock = new()
        //                {
        //                    PalletCode = generate.PalletCode,
        //                    IsFull = true,
        //                    StockStatus = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                    MaterialType = (int)InventoryMaterialType.成品,
        //                    Materialweight = 0,
        //                };
        //                _unitOfWorkManage.BeginTran();
        //                _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //                //string part2 = generate.PalletCode.Substring(2, 8);

        //                //string part3 = generate.PalletCode.Split('#')[1];
        //                Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                {
        //                    StockId = dt_StockInfo2.Id,
        //                    MaterielCode = dt_StockInfo2.PalletCode,    //物料编号
        //                    MaterielName = dt_StockInfo2.PalletCode,    //材质
        //                    OrderNo = dt_StockInfo2.PalletCode,        //单据（托盘条码）
        //                    BatchNo = dt_StockInfo2.PalletCode,         //批次号
        //                    SerialNumber = dt_StockInfo2.PalletCode,    //序列号
        //                    StockQuantity = 1,    //序列号
        //                    OutboundQuantity = 1,    //序列号
        //                    Status = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                };
        //                _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);

        //                _unitOfWorkManage.CommitTran();
        //                return content = WebResponseContent.Instance.OK(data: 1);
        //            }
        //            else
        //            {
        //                if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                {
        //                    return content = WebResponseContent.Instance.OK(data: 1);
        //                }
        //                else
        //                {
        //                    return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                }
        //            }
        //        }
        //        else
        //        {
        //            Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.UpperOrderNo == result);
        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //            List<Dt_LocationInfo> locationinfoData = _basicService.LocationInfoService.Repository.QueryData(x => x.RoadwayNo == "2" && x.LocationStatus == LocationStatusEnum.Free.ObjToInt()
        //                    && x.LocationType == (int)LocationTypeEnum.MaterialsCube);
        //            if (dt_Inbound != null)
        //            {
        //                if (dt_StockInfo == null)
        //                {
        //                    Dt_StockInfo dt_Stock = new()
        //                    {
        //                        PalletCode = generate.PalletCode,
        //                        IsFull = true,
        //                        StockStatus = (int)StockStatusEmun.组盘暂存,
        //                        Creater = "WMS",
        //                        CreateDate = DateTime.Now,
        //                        MaterialType = (int)InventoryMaterialType.原材料,
        //                        Materialweight = 0,
        //                    };
        //                    _unitOfWorkManage.BeginTran();
        //                    _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //                    string part2 = generate.PalletCode.Substring(2, 8);

        //                    string part3 = generate.PalletCode.Split('#')[1];
        //                    Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                    Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                    {
        //                        StockId = dt_StockInfo2.Id,
        //                        MaterielCode = result,    //物料编号
        //                        MaterielName = dt_Inbound.OrderNo,    //材质
        //                        OrderNo = generate.PalletCode,        //单据（托盘条码）
        //                        BatchNo = part2,         //批次号
        //                        SerialNumber = part3,    //序列号
        //                        StockQuantity = 1,    //序列号
        //                        OutboundQuantity = 1,    //序列号
        //                        Status = (int)StockStatusEmun.组盘暂存,
        //                        Creater = "WMS",
        //                        CreateDate = DateTime.Now,
        //                    };
        //                    _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);

        //                    _unitOfWorkManage.CommitTran();


        //                    if (locationinfoData.Count > 40)
        //                    {
        //                        return content = WebResponseContent.Instance.OK(data: 3);
        //                    }
        //                    else
        //                    {
        //                        return content = WebResponseContent.Instance.OK(data: 1);
        //                    }

        //                }
        //                else
        //                {
        //                    if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                    {
        //                        if (locationinfoData.Count > 40)
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 3);
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 1);
        //                        }
        //                    }
        //                    else
        //                    {
        //                        return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                    }
        //                }

        //            }
        //            else
        //            {
        //                return content = WebResponseContent.Instance.Error("未找到该类型的解析");
        //            }

        //        }
        //    }
        //    catch (Exception ex)
        //    {

        //        throw;
        //    }
        //}
    }
}