ÏîÄ¿´úÂë/WIDESEA_WMSClient/src/views/outbound/PickingConfirm.vue

@@ -30,7 +30,7 @@
          <el-button type="info" @click="openRevertSplitDialog">撤销拆包</el-button>
      
          <el-button type="primary" @click="openBatchReturnDialog">回库</el-button>
          <el-button type="danger" @click="handleDirectOutbound">直接出库</el-button> 
          <!-- <el-button type="danger" @click="handleDirectOutbound">直接出库</el-button>  -->

        </div>
      </el-card>
@@ -42,7 +42,7 @@
        <div class="summary-info">
          <el-tag type="warning">未拣选条数: {{summary.unpickedCount}}</el-tag>
          <el-tag type="danger">未拣选数量: {{summary.unpickedQuantity}}</el-tag>
          <el-tag type="success">已拣选条数: {{summary.pickedCount}}</el-tag>
    <!--       <el-tag type="success">已拣选条数: {{summary.pickedCount}}</el-tag> -->
          <el-tag type="info">托盘状态: {{palletStatus}}</el-tag>
        </div>
      </el-card>
@@ -552,7 +552,7 @@
      }
    },

    // æ‰¹é‡å›žåº“托盘码扫码
    // å›žåº“托盘码扫码
    onBatchReturnPalletScan() {
      if (!this.batchReturnForm.palletCode) return;
      
@@ -564,7 +564,7 @@
      }
    },

    // æ‰¹é‡å›žåº“确认
    // å›žåº“确认
    async handleBatchReturnConfirm() {
      // è¡¨å•éªŒè¯
      if (this.$refs.batchReturnFormRef) {
@@ -587,25 +587,25 @@
      }
    },
    
    // æäº¤æ‰¹é‡å›žåº“请求
    // æäº¤å›žåº“请求
    async submitBatchReturn() {
      this.batchReturnLoading = true;
      
      try {
        const res = await this.http.post('/api/OutboundPicking/batch-return-to-stock', {
        const res = await this.http.post('/api/OutboundPicking/return-to-stock', {
          orderNo: this.batchReturnForm.orderNo,
          palletCode: this.batchReturnForm.palletCode
        });
        
        if (res.status) {
          this.$message.success('批量回库成功');
          this.$message.success('回库成功');
          this.showBatchReturnDialog = false;
          this.loadData();
        } else {
          this.$message.error(res.message || '批量回库失败');
          this.$message.error(res.message || '回库失败');
        }
      } catch (error) {
        this.$message.error('批量回库失败');
        this.$message.error('回库失败');
      } finally {
        this.batchReturnLoading = false;
      }
@@ -979,7 +979,7 @@
          barcode: this.returnForm.barcode
        });
        
        if (res.success) {
        if (res.status) {
          this.$message.success('回库成功');
          this.showReturnDialog = false;
          this.resetReturnForm();

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_AllocateService/AllocateService.cs

@@ -28,7 +28,7 @@
        public readonly IOutboundService _outboundService;
        public readonly IRepository<Dt_AllocateOrder> _allocateOrderRepository;
        public readonly IRepository<Dt_AllocateOrderDetail> _allocateOrderDetailRepository;
        public AllocateService(IRepository<Dt_AllocateOrder> BaseDal, 
        public AllocateService(IRepository<Dt_AllocateOrder> BaseDal,
            IUnitOfWorkManage unitOfWorkManage,
            IInboundService inboundService,
            IOutboundService outboundService,
@@ -103,81 +103,81 @@
        {
            try
            {
                    var allocateOrder = Db.Queryable<Dt_AllocateOrder>().Where(x => x.UpperOrderNo == model.UpperOrderNo).Includes(x => x.Details).First();
                    if (allocateOrder == null)
                var allocateOrder = Db.Queryable<Dt_AllocateOrder>().Where(x => x.UpperOrderNo == model.UpperOrderNo).Includes(x => x.Details).First();
                if (allocateOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到调拨单信息");
                }
                if (allocateOrder.Details == null || allocateOrder.Details.Count == 0)
                {
                    return WebResponseContent.Instance.Error($"未找到调拨单明细信息");
                }
                List<Dt_AllocateOrderDetail> allocateOrderDetails = new List<Dt_AllocateOrderDetail>();
                List<Dt_AllocateOrderDetail> updateAllocateOrderDetails = new List<Dt_AllocateOrderDetail>();
                List<int> detailIds = new List<int>();
                foreach (var item in model.Details)
                {
                    if (string.IsNullOrEmpty(item.Barcode))
                    {
                        return WebResponseContent.Instance.Error($"未找到调拨单信息");
                    }
                    if (allocateOrder.Details == null || allocateOrder.Details.Count == 0)
                    {
                        return WebResponseContent.Instance.Error($"未找到调拨单明细信息");
                    }
                    List<Dt_AllocateOrderDetail> allocateOrderDetails = new List<Dt_AllocateOrderDetail>();
                    List<Dt_AllocateOrderDetail> updateAllocateOrderDetails = new List<Dt_AllocateOrderDetail>();
                    List<int> detailIds = new List<int>();
                    foreach (var item in model.Details)
                    {
                        if (string.IsNullOrEmpty(item.Barcode))
                        {

                    }
                    else
                    {
                        Dt_AllocateOrderDetail? allocateOrderDetail = allocateOrder.Details.FirstOrDefault(x => x.Barcode == item.Barcode);
                        if (allocateOrderDetail == null)
                        {
                            allocateOrderDetail = new Dt_AllocateOrderDetail()
                            {
                                OrderId = allocateOrder.Id,
                                MaterielCode = item.MaterielCode,
                                LineNo = item.LineNo,
                                BatchNo = item.BatchNo,
                                Unit = item.Unit,
                                WarehouseCode = item.WarehouseCode,
                                Barcode = item.Barcode,
                                BarcodeUnit = item.BarcodeUnit,
                                BarcodeQty = (decimal)item.BarcodeQty,
                                OrderQuantity = item.OrderQuantity
                            };
                            allocateOrderDetails.Add(allocateOrderDetail);
                        }
                        else
                        {
                            Dt_AllocateOrderDetail? allocateOrderDetail = allocateOrder.Details.FirstOrDefault(x => x.Barcode == item.Barcode);
                            if (allocateOrderDetail == null)
                            {
                                allocateOrderDetail = new Dt_AllocateOrderDetail()
                                {
                                    OrderId = allocateOrder.Id,
                                    MaterielCode = item.MaterielCode,
                                    LineNo= item.LineNo,
                                    BatchNo = item.BatchNo,
                                    Unit = item.Unit,
                                    WarehouseCode = item.WarehouseCode,
                                    Barcode = item.Barcode,
                                    BarcodeUnit = item.BarcodeUnit,
                                    BarcodeQty = (decimal)item.BarcodeQty,
                                    OrderQuantity = item.OrderQuantity
                                };
                                allocateOrderDetails.Add(allocateOrderDetail);
                            }
                            else
                            {
                                allocateOrderDetail.LineNo = item.LineNo;
                                allocateOrderDetail.MaterielCode = item.MaterielCode;
                                allocateOrderDetail.BatchNo = item.BatchNo;
                                allocateOrderDetail.Unit = item.Unit;
                                allocateOrderDetail.WarehouseCode = item.WarehouseCode;
                                allocateOrderDetail.Barcode = item.Barcode;
                                allocateOrderDetail.BarcodeUnit = item.BarcodeUnit;
                                allocateOrderDetail.BarcodeQty = item.BarcodeQty;
                                allocateOrderDetail.OrderQuantity = item.OrderQuantity;
                            allocateOrderDetail.LineNo = item.LineNo;
                            allocateOrderDetail.MaterielCode = item.MaterielCode;
                            allocateOrderDetail.BatchNo = item.BatchNo;
                            allocateOrderDetail.Unit = item.Unit;
                            allocateOrderDetail.WarehouseCode = item.WarehouseCode;
                            allocateOrderDetail.Barcode = item.Barcode;
                            allocateOrderDetail.BarcodeUnit = item.BarcodeUnit;
                            allocateOrderDetail.BarcodeQty = item.BarcodeQty;
                            allocateOrderDetail.OrderQuantity = item.OrderQuantity;


                                updateAllocateOrderDetails.Add(allocateOrderDetail);
                                detailIds.Add(allocateOrderDetail.Id);
                            }
                            updateAllocateOrderDetails.Add(allocateOrderDetail);
                            detailIds.Add(allocateOrderDetail.Id);
                        }
                    }
                }

                    allocateOrder.UpperOrderNo = model.UpperOrderNo;
                    allocateOrder.BusinessType = model.BusinessType;
                    allocateOrder.IsBatch = model.IsBatch;
                    allocateOrder.FactoryArea = model.FactoryArea;
                allocateOrder.UpperOrderNo = model.UpperOrderNo;
                allocateOrder.BusinessType = model.BusinessType;
                allocateOrder.IsBatch = model.IsBatch;
                allocateOrder.FactoryArea = model.FactoryArea;

                    List<Dt_AllocateOrderDetail> deletePurchaseOrderDetails = allocateOrder.Details.Where(x => !detailIds.Contains(x.Id)).ToList();
                List<Dt_AllocateOrderDetail> deletePurchaseOrderDetails = allocateOrder.Details.Where(x => !detailIds.Contains(x.Id)).ToList();

                    _unitOfWorkManage.BeginTran();
                    foreach (var item in deletePurchaseOrderDetails)
                    {
                        _allocateOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                    }
                _unitOfWorkManage.BeginTran();
                foreach (var item in deletePurchaseOrderDetails)
                {
                    _allocateOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                }

                    _allocateOrderDetailRepository.UpdateData(updateAllocateOrderDetails);
                    _allocateOrderDetailRepository.AddData(allocateOrderDetails);
                _allocateOrderDetailRepository.UpdateData(updateAllocateOrderDetails);
                _allocateOrderDetailRepository.AddData(allocateOrderDetails);

                    BaseDal.UpdateData(allocateOrder);
                    _unitOfWorkManage.CommitTran();
                BaseDal.UpdateData(allocateOrder);
                _unitOfWorkManage.CommitTran();


                return WebResponseContent.Instance.OK();
@@ -193,23 +193,25 @@
        {
            try
            {
                    var allocateOrder = Db.Queryable<Dt_AllocateOrder>().Where(x => x.UpperOrderNo == model.UpperOrderNo).Includes(x => x.Details).First();
                    if (allocateOrder == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到调拨单信息");
                    }
                    if (allocateOrder.Details == null || allocateOrder.Details.Count == 0)
                    {
                        return WebResponseContent.Instance.Error($"未找到调拨单明细信息");
                    }
                    //Db.DeleteNav(inboundOrder).Include(x => x.Details).ExecuteCommand();
                    _unitOfWorkManage.BeginTran();
                    BaseDal.DeleteAndMoveIntoHty(allocateOrder, OperateTypeEnum.自动删除);
                    foreach (var item in allocateOrder.Details)
                    {
                        _allocateOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                    }
                    _unitOfWorkManage.CommitTran();
                var allocateOrder = Db.Queryable<Dt_AllocateOrder>().Where(x => x.UpperOrderNo == model.UpperOrderNo).Includes(x => x.Details).First();
                if (allocateOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到调拨单信息");
                }
                if (allocateOrder.Details == null || allocateOrder.Details.Count == 0)
                {
                    return WebResponseContent.Instance.Error($"未找到调拨单明细信息");
                }
                //Db.DeleteNav(inboundOrder).Include(x => x.Details).ExecuteCommand();
                _unitOfWorkManage.BeginTran();
                // BaseDal.DeleteAndMoveIntoHty(allocateOrder, OperateTypeEnum.自动删除);
                foreach (var item in allocateOrder.Details)
                {
                    // _allocateOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                    _allocateOrderDetailRepository.DeleteData(item);
                }
                BaseDal.DeleteData(allocateOrder);
                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
@@ -262,34 +264,34 @@
        {
            return new Dt_OutboundOrder()
            {
                   WarehouseId= allocateOrder.WarehouseId,
                   OrderNo=allocateOrder.OrderNo,
                   UpperOrderNo=allocateOrder.UpperOrderNo,
                   OrderType=allocateOrder.OrderType,
                   OrderStatus=allocateOrder.OrderStatus,
                   CreateType=allocateOrder.CreateType,
                   BusinessType=allocateOrder.BusinessType,
                   IsBatch=allocateOrder.IsBatch,
                   FactoryArea=allocateOrder.FactoryArea,
                   Remark=allocateOrder.Remark,
                   DepartmentCode="",
                   DepartmentName="",
                   Details=allocateOrder.Details.Select(detail=>new Dt_OutboundOrderDetail
                   {
                       OrderId= detail.OrderId,
                       MaterielCode=detail.MaterielCode,
                       MaterielName="",
                       BatchNo=detail.BatchNo,
                       OrderQuantity=detail.OrderQuantity,
                       LockQuantity=0,
                       OverOutQuantity=0,
                       OrderDetailStatus=detail.OrderDetailStatus,
                       Unit=detail.Unit,
                       RowNo=0,
                       SupplyCode="",
                       WarehouseCode=detail.WarehouseCode,
                       
                   }).ToList()
                WarehouseId = allocateOrder.WarehouseId,
                OrderNo = allocateOrder.OrderNo,
                UpperOrderNo = allocateOrder.UpperOrderNo,
                OrderType = allocateOrder.OrderType,
                OrderStatus = allocateOrder.OrderStatus,
                CreateType = allocateOrder.CreateType,
                BusinessType = allocateOrder.BusinessType,
                IsBatch = allocateOrder.IsBatch,
                FactoryArea = allocateOrder.FactoryArea,
                Remark = allocateOrder.Remark,
                DepartmentCode = "",
                DepartmentName = "",
                Details = allocateOrder.Details.Select(detail => new Dt_OutboundOrderDetail
                {
                    OrderId = detail.OrderId,
                    MaterielCode = detail.MaterielCode,
                    MaterielName = "",
                    BatchNo = detail.BatchNo,
                    OrderQuantity = detail.OrderQuantity,
                    LockQuantity = 0,
                    OverOutQuantity = 0,
                    OrderDetailStatus = detail.OrderDetailStatus,
                    Unit = detail.Unit,
                    RowNo = 0,
                    SupplyCode = "",
                    WarehouseCode = detail.WarehouseCode,

                }).ToList()
            };
        }


 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_BasicService/ESSApiService.cs

@@ -35,6 +35,11 @@
                var result = await PostAsync<MoveContainerRequest, ApiResponse<string>>(url, request);
                if (result != null && result.Code == 0)
                {
                    //{"code":0,"msg":"success","data":{"107":"TASK_ALREADY_EXIST"}}
                    if (result.Data.Contains("TASK_ALREADY_EXIST"))
                    {
                        return false;
                    }
                    return true;
                }
                return false;

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_DTO/Task/WMSTaskDTO.cs

@@ -72,4 +72,13 @@
        public int PalletType { get; set; }

    }


    public class GenerateOutboundTasksDto
    {
        public string outboundPlatform { get; set; }

        public int[] taskIds { get; set; }

    }
}

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_IOutboundService/IOutboundPickingService.cs

@@ -15,20 +15,17 @@
    {
        IRepository<Dt_PickingRecord> Repository { get; }

        Task<WebResponseContent> CancelPicking(CancelPickingRequest request);
        Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode);
        Task<WebResponseContent> ConfirmPicking(PickingConfirmRequest request);
        Task<bool> CheckPalletNeedReturn(string orderNo, string palletCode);
        Task<WebResponseContent> ConfirmPicking(string orderNo, string palletCode, string barcode);
        Task<WebResponseContent> DirectOutbound(DirectOutboundRequest request);
 
        Task<List<OutStockLockListResp>> GetOutStockLockListAsync(string orderNo);
        Task<WebResponseContent> GetPalletOutboundStatus(string palletCode);
        Task GetPalletPickingSummary(string orderNo, string palletCode);
        Task<List<Dt_OutStockLockInfo>> GetPickedList(string orderNo, string palletCode);
        Task<List<Dt_PickingRecord>> GetPickingHistory(int orderId);
        Task<object> GetPickingSummary(ConfirmPickingDto dto);
   
        Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode);
        Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason);
        Task<WebResponseContent> ValidateBarcode(string barcode);
    }
}

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_ITaskInfoService/ITaskService.cs

@@ -44,7 +44,7 @@

        Task<WebResponseContent> TaskCompleted(string taskNum);

        Task<WebResponseContent> GenerateOutboundTasksAsync(int[] keys);
        Task<WebResponseContent> GenerateOutboundTasksAsync(int[] keys, string outStation);
 
    }
}

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_InboundService/InboundOrderService.cs

@@ -223,11 +223,13 @@
                    }
                    //Db.DeleteNav(inboundOrder).Include(x => x.Details).ExecuteCommand();
                    _unitOfWorkManage.BeginTran();
                    BaseDal.DeleteAndMoveIntoHty(inboundOrder, OperateTypeEnum.自动删除);
                    //BaseDal.DeleteAndMoveIntoHty(inboundOrder, OperateTypeEnum.自动删除);
                    foreach (var item in inboundOrder.Details)
                    {
                        _inboundOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                        _inboundOrderDetailRepository.DeleteData(item);
                        //_inboundOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                    }
                    BaseDal.DeleteData(inboundOrder);
                    _unitOfWorkManage.CommitTran();
                }
                return WebResponseContent.Instance.OK();
@@ -458,6 +460,7 @@
                    {
                        stockInfo.PalletType = PalletTypeEnum.Empty.ObjToInt();
                        stockInfo.StockStatus = StockStatusEmun.组盘暂存.ObjToInt();
                        stockInfo.LocationType = materielGroupDTO.WarehouseCode.ObjToInt();
                    }

                    _unitOfWorkManage.BeginTran();

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_Model/Models/Outbound/Dt_OutboundOrderDetail.cs

@@ -114,5 +114,7 @@

        [SugarColumn(IsIgnore = true)]
        public decimal NeedOutQuantity => OrderQuantity - MoveQty;

        public decimal PickedQty { get; set; }
    }
}

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundOrderService.cs

@@ -1,6 +1,7 @@
using Autofac.Core;
using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using SqlSugar;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
@@ -19,14 +20,15 @@
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        public IRepository<Dt_OutboundOrder> Repository => BaseDal;

        private readonly ILogger<OutboundOrderService> _logger;
        private readonly IRepository<Dt_OutboundOrderDetail> _outboundOrderDetailRepository;

        public OutboundOrderService(IRepository<Dt_OutboundOrder> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_OutboundOrderDetail> outboundOrderDetailRepository) : base(BaseDal)
        public OutboundOrderService(IRepository<Dt_OutboundOrder> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_OutboundOrderDetail> outboundOrderDetailRepository, ILogger<OutboundOrderService> logger) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _outboundOrderDetailRepository = outboundOrderDetailRepository;
            _logger = logger;
        }

        public WebResponseContent ReceiveOutboundOrder(Dt_OutboundOrder model, int operateType)
@@ -163,13 +165,15 @@
                {
                    return WebResponseContent.Instance.Error($"未找到出库单明细信息");
                }
                //Db.DeleteNav(inboundOrder).Include(x => x.Details).ExecuteCommand();
                
                _unitOfWorkManage.BeginTran();
                BaseDal.DeleteAndMoveIntoHty(outboundOrder, OperateTypeEnum.自动删除);
                //BaseDal.DeleteAndMoveIntoHty(outboundOrder, OperateTypeEnum.自动删除);
                foreach (var item in outboundOrder.Details)
                {
                    _outboundOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);
                    // _outboundOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.自动删除);\\
                    _outboundOrderDetailRepository.DeleteData(item);
                }
                BaseDal.DeleteData(outboundOrder);
                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK();
@@ -177,6 +181,7 @@
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                _logger.LogInformation(ex.Message);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundPickingService.cs

@@ -1,6 +1,7 @@
using Dm.filter;
using MailKit.Search;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using SqlSugar;
using System;
using System.Collections.Generic;
@@ -10,10 +11,12 @@
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Outbound;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundService;
@@ -39,9 +42,26 @@
        private readonly IOutboundOrderService _outboundOrderService;
        private readonly ISplitPackageService _splitPackageService;
        private readonly IRepository<Dt_Task> _taskRepository;
        private readonly IESSApiService _eSSApiService;


        public OutboundPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService, IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService, IRepository<Dt_Task> taskRepository) : base(BaseDal)
        private readonly ILogger<OutboundPickingService> _logger;

        private Dictionary<string, string> stations = new Dictionary<string, string>
        {
            {"2-1","2-9" },
            {"3-1","3-9" },

        };

        private Dictionary<string, string> movestations = new Dictionary<string, string>
        {
            {"2-1","2-5" },
            {"3-1","3-5" },

        };

        public OutboundPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService, IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService, IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
@@ -53,6 +73,8 @@
            _splitPackageService = splitPackageService;
            _outboundOrderService = outboundOrderService;
            _taskRepository = taskRepository;
            _eSSApiService = eSSApiService;
            _logger = logger;
        }


@@ -117,157 +139,79 @@
            }
        }

        /// <summary>
        /// æ‰«ç æ‹£é€‰ç¡®è®¤ 
        /// </summary>
        public async Task<WebResponseContent> ConfirmPicking(PickingConfirmRequest request)
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                // 1. éªŒè¯æ¡ç æœ‰æ•ˆæ€§
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == request.Barcode && x.MaterielCode == request.MaterielCode)
                    .FirstAsync();

                if (stockDetail == null)
                    return WebResponseContent.Instance.Error("无效的条码或物料编码");

                // 2. æ£€æŸ¥åº“存可用数量
                decimal availableQuantity = stockDetail.StockQuantity - stockDetail.OutboundQuantity;
                if (request.PickQuantity > availableQuantity)
                    return WebResponseContent.Instance.Error($"拣选数量超过可用库存，可用数量：{availableQuantity}");

                // 3. æŸ¥æ‰¾ç›¸å…³çš„出库锁定信息（支持拆包后的新条码）
                var lockInfo = await FindLockInfoByBarcode(request.OrderDetailId, request.Barcode, request.MaterielCode);

                if (lockInfo == null)
                    return WebResponseContent.Instance.Error("未找到相关的出库锁定信息");

                // 4. æ£€æŸ¥é”å®šæ•°é‡
                decimal remainingLockQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;
                if (request.PickQuantity > remainingLockQuantity)
                    return WebResponseContent.Instance.Error($"拣选数量超过锁定数量，剩余可拣选：{remainingLockQuantity}");

                // 5. æ›´æ–°é”å®šä¿¡æ¯çš„已拣选数量
                lockInfo.PickedQty += request.PickQuantity;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // 6. æ›´æ–°åº“存出库数量 - å®žé™…减少库存
                stockDetail.OutboundQuantity += request.PickQuantity;
                await _stockInfoService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                // 7. æ›´æ–°å‡ºåº“单明细
                var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                    .Where(x => x.Id == request.OrderDetailId)
                    .FirstAsync();

                orderDetail.OverOutQuantity += request.PickQuantity;
                orderDetail.LockQuantity -= request.PickQuantity;

                // æ£€æŸ¥æ˜¯å¦å®Œæˆå‡ºåº“
                if (Math.Abs(orderDetail.OverOutQuantity - orderDetail.OrderQuantity) < 0.001m)
                {
                    orderDetail.OrderDetailStatus = (int)OrderDetailStatusEnum.Over;
                    orderDetail.LockQuantity = 0;

                    // æ›´æ–°ç›¸å…³çš„锁定信息状态为已出库
                    var relatedLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                        .Where(x => x.OrderDetailId == request.OrderDetailId &&
                                   x.Status == (int)OutLockStockStatusEnum.出库中)
                        .ToListAsync();

                    foreach (var relatedLock in relatedLockInfos)
                    {
                        relatedLock.Status = (int)OutLockStockStatusEnum.已出库;
                    }
                    await _outStockLockInfoService.Db.Updateable(relatedLockInfos).ExecuteCommandAsync();
                }

                await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

                // 8. è®°å½•æ‹£é€‰åŽ†å²
                var pickHistory = new Dt_PickingRecord
                {
                    OrderDetailId = request.OrderDetailId,
                    Barcode = request.Barcode,
                    PickQuantity = request.PickQuantity,
                    PickTime = DateTime.Now,

                    LocationCode = request.LocationCode,
                    StockId = stockDetail.StockId
                };
                await Db.Insertable(pickHistory).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK("拣选确认成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error($"拣选确认失败: {ex.Message}");
            }
        }

        public async Task<WebResponseContent> ConfirmPicking(string orderNo, string palletCode, string barcode)
        {
            try
            {
                _unitOfWorkManage.BeginTran();
                // 1. éªŒè¯æ¡ç æœ‰æ•ˆæ€§
                var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                  .Where(it => it.OrderNo == orderNo &&
                             it.Status == (int)OutLockStockStatusEnum.出库中 &&
                             it.PalletCode == palletCode &&
                             it.CurrentBarcode == barcode)
                  .FirstAsync();

                if (lockInfo == null)
                {
                    var splitBarcode = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                   .Where(it => it.NewBarcode == barcode && it.Status == 1)
                   .FirstAsync();

                    if (splitBarcode != null)
                    {
                        // é€šè¿‡æ‹†åŒ…条码记录找到对应的出库锁定记录
                        lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                            .Where(it => it.ParentLockId == splitBarcode.OutStockLockInfoId)
                            .FirstAsync();

                        if (lockInfo == null)
                            throw new Exception($"未找到拆包条码{barcode}对应的出库锁定记录");
                    }
                    else
                    {
                        throw new Exception($"条码{barcode}不属于托盘{palletCode}或不存在待分拣记录");
                    }

                }
                if (lockInfo.PalletCode != palletCode)
                    throw new Exception($"条码{barcode}不属于托盘{palletCode}");

                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .Where(x => x.Barcode == barcode)
                        .Where(x => x.Barcode == barcode && x.StockId == lockInfo.StockId)
                        .FirstAsync();

                if (stockDetail == null)
                    return WebResponseContent.Instance.Error("无效的条码或物料编码");

                //// 2. æ£€æŸ¥åº“存可用数量
                //var availableQty = stockDetail.StockQuantity - stockDetail.OutboundQuantity;
                //if (availableQty <= 0)
                //    return WebResponseContent.Instance.Error("库存数量不足");

                // 3. æŸ¥æ‰¾ç›¸å…³çš„出库详情信息
                var outStockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               x.CurrentBarcode == barcode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中 &&
                               x.AssignQuantity - x.PickedQty > 0)
                    .FirstAsync();
                decimal actualQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                // 4. æ›´æ–°åº“å­˜
                stockDetail.StockQuantity -= actualQty;
                stockDetail.OutboundQuantity -= actualQty;
                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                if (outStockInfo == null)
                    return WebResponseContent.Instance.Error("未找到对应的拣选信息或已拣选完成");
                lockInfo.PickedQty += actualQty;
                lockInfo.Status = (int)OutLockStockStatusEnum.拣选完成;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // 4. æ£€æŸ¥å‡ºåº“详情锁定数量
                if (outStockInfo.RemainQuantity <= 0)
                    return WebResponseContent.Instance.Error("该条码已无剩余可拣选数量");
                var splitBarcodeRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
               .Where(it => it.NewBarcode == barcode)
               .FirstAsync();

                // 5. æ›´æ–°å‡ºåº“详情的已拣选数量
                outStockInfo.PickedQty = outStockInfo.AssignQuantity;
                outStockInfo.Status = (int)OutLockStockStatusEnum.已拣选;
                await _outStockLockInfoService.Db.Updateable(outStockInfo).ExecuteCommandAsync();

                //// 6. æ›´æ–°åº“存出库数量
                //await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
                //    .SetColumns(x => x.OutboundQuantity == x.OutboundQuantity + outStockInfo.AssignQuantity)
                //    .Where(x => x.Id == stockDetail.Id)
                //    .ExecuteCommandAsync();

                // 7. æ›´æ–°å‡ºåº“单明细
                var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                    .Where(x => x.Id == outStockInfo.OrderDetailId)
                    .FirstAsync();
                if (orderDetail != null)
                if (splitBarcodeRecord != null)
                {
                    orderDetail.OverOutQuantity += outStockInfo.AssignQuantity;
                    orderDetail.LockQuantity -= outStockInfo.AssignQuantity;
                    await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
                    splitBarcodeRecord.Status = 2;
                    await _splitPackageService.Db.Updateable(splitBarcodeRecord).ExecuteCommandAsync();
                }
                // 8. æ£€æŸ¥æ˜¯å¦å®Œæˆå‡ºåº“

                await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
               .SetColumns(it => it.PickedQty == it.PickedQty + actualQty)
               .Where(it => it.Id == lockInfo.OrderDetailId)
               .ExecuteCommandAsync();


                await CheckAndUpdateOrderStatus(orderNo);

                //查询任务表 
@@ -275,19 +219,19 @@
                // 9. è®°å½•æ‹£é€‰åŽ†å²
                var pickingHistory = new Dt_PickingRecord
                {
                    FactoryArea = outStockInfo.FactoryArea,
                    FactoryArea = lockInfo.FactoryArea,
                    TaskNo = task?.TaskNum ?? 0,
                    LocationCode = task?.SourceAddress ?? "",
                    StockId = stockDetail.Id,
                    OrderNo = orderNo,
                    OrderDetailId = orderDetail?.Id ?? 0,
                    OrderDetailId = lockInfo.OrderDetailId,
                    PalletCode = palletCode,
                    Barcode = barcode,
                    MaterielCode = outStockInfo.MaterielCode,
                    PickQuantity = outStockInfo.AssignQuantity,
                    MaterielCode = lockInfo.MaterielCode,
                    PickQuantity = lockInfo.AssignQuantity,
                    PickTime = DateTime.Now,
                    Operator = App.User.UserName,
                    OutStockLockId = outStockInfo.Id
                    OutStockLockId = lockInfo.Id
                };
                await Db.Insertable(pickingHistory).ExecuteCommandAsync();

@@ -327,6 +271,396 @@
                    .ExecuteCommandAsync();
            }
        }


        /// <summary>
        /// å›žåº“操作  
        /// </summary>
        //public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
        //{
        //    try
        //    {
        //        // 1. èŽ·å–所有未分拣的出库锁定记录，包括拆包产生的记录
        //        var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
        //            .Where(it => it.OrderNo == orderNo && it.Status == 1)
        //            .ToListAsync();

        //        if (!remainingLocks.Any())
        //        {
        //            return WebResponseContent.Instance.Error("没有需要回库的剩余货物");
        //        }
        //        var tasks = new List<Dt_Task>();
        //        // æŒ‰æ‰˜ç›˜åˆ†ç»„
        //        var palletGroups = remainingLocks.GroupBy(x => x.PalletCode);
        //        //查询任务表 
        //        var task = _taskRepository.QueryData(x => x.TaskNum == remainingLocks.First().TaskNum).FirstOrDefault();
        //        foreach (var group in palletGroups)
        //        {
        //            if (group.Key == palletCode)
        //            {
        //                var totalReturnQty = group.Sum(x => x.AssignQuantity - x.PickedQty);

        //                if (totalReturnQty <= 0) continue;

        //                // åˆ†é…æ–°è´§ä½
        //                var newLocation = _locationInfoService.AssignLocation();

        //                // æ›´æ–°å‡ºåº“锁定记录状态
        //                var lockIds = group.Where(x => x.PalletCode == palletCode).Select(x => x.Id).ToList();
        //                await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
        //                    .SetColumns(it => new Dt_OutStockLockInfo { Status = OutLockStockStatusEnum.回库中.ObjToInt() })
        //                    .Where(it => lockIds.Contains(it.Id))
        //                    .ExecuteCommandAsync();

        //                // æ›´æ–°æ‹†åŒ…条码记录状态
        //                var splitBarcodes = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
        //                    .Where(it => lockIds.Contains(it.OutStockLockInfoId))
        //                    .ToListAsync();

        //                foreach (var splitBarcode in splitBarcodes)
        //                {
        //                    splitBarcode.Status = 3;
        //                    await _splitPackageService.Db.Updateable(splitBarcode).ExecuteCommandAsync();
        //                }

        //                foreach (var lockInfo in group)
        //                {
        //                    if (lockInfo.PalletCode == palletCode)
        //                    {
        //                        decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

        //                        // æ£€æŸ¥åº“存记录是否存在
        //                        var existingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
        //                            .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
        //                            .FirstAsync();

        //                        if (existingStock != null)
        //                        {
        //                            // åº“存记录存在，恢复锁定数量
        //                            await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
        //                                .SetColumns(it => new Dt_StockInfoDetail
        //                                {
        //                                    OutboundQuantity = it.OutboundQuantity - returnQty
        //                                })
        //                                .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
        //                                .ExecuteCommandAsync();
        //                        }
        //                        else
        //                        {
        //                            // åº“存记录不存在（可能是拆包产生的新条码），创建新的库存记录
        //                            var newStockDetail = new Dt_StockInfoDetail
        //                            {
        //                                StockId = lockInfo.StockId,
        //                                MaterielCode = lockInfo.MaterielCode,
        //                                OrderNo = lockInfo.OrderNo,
        //                                BatchNo = lockInfo.BatchNo,
        //                                StockQuantity = returnQty, // å®žé™…库存数量
        //                                OutboundQuantity = 0, // å›žåº“后不再锁定
        //                                Barcode = lockInfo.CurrentBarcode,
        //                                InboundOrderRowNo = "0",
        //                                Status = StockStatusEmun.入库确认.ObjToInt(),

        //                            };
        //                            await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
        //                        }
        //                    }
        //                }


        //                Dt_Task newtask = new()
        //                {
        //                    CurrentAddress = stations[task.TargetAddress],
        //                    Grade = 0,
        //                    PalletCode = palletCode,
        //                    NextAddress = "",
        //                    OrderNo= task.OrderNo,
        //                    Roadway = newLocation.RoadwayNo,
        //                    SourceAddress = stations[task.TargetAddress],
        //                    TargetAddress = newLocation.LocationCode,
        //                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
        //                    TaskType = TaskTypeEnum.InPick.ObjToInt(),
        //                    // TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
        //                    PalletType = task.PalletType,
        //                    WarehouseId = task.WarehouseId,
        //                };
        //                tasks.Add(newtask);

        //            }
        //        }
        //        try
        //        {
        //            await _taskRepository.Db.Insertable(tasks).ExecuteCommandAsync();
        //            //删除 å‡ºåº“çš„  task


        //            //给 ess  æµåŠ¨ä¿¡å·  å’Œåˆ›å»ºä»»åŠ¡


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

        //        }




        //        return WebResponseContent.Instance.OK();
        //    }
        //    catch (Exception ex)
        //    {
        //        return WebResponseContent.Instance.Error($"回库操作失败: {ex.Message}");
        //    }
        //}

        public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
        {
            try
            {
                // 1. èŽ·å–所有未分拣的出库锁定记录，包括拆包产生的记录
                var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(it => it.OrderNo == orderNo && it.Status == 1)
                    .ToListAsync();

                var stockinfo = _stockInfoService.Db.Queryable<Dt_StockInfo>().First(x => x.PalletCode == palletCode);

                // 2. æ£€æŸ¥æ‰˜ç›˜ä¸Šæ˜¯å¦æœ‰å…¶ä»–非出库货物（库存货物）
                var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(it => it.StockId == stockinfo.Id && it.Status == StockStatusEmun.入库确认.ObjToInt())
                    .Where(it => it.OutboundQuantity == 0 || it.OutboundQuantity < it.StockQuantity) // æœªå®Œå…¨å‡ºåº“çš„
                    .ToListAsync();

                // 3. å¦‚果没有需要回库的货物（既无未分拣出库货物，也无其他库存货物）
                if (!remainingLocks.Any() && !palletStockGoods.Any())
                {
                    return WebResponseContent.Instance.Error("没有需要回库的剩余货物");
                }

                var tasks = new List<Dt_Task>();

                // æŸ¥è¯¢ä»»åŠ¡è¡¨
                var task = remainingLocks.Any()
                    ? _taskRepository.QueryData(x => x.TaskNum == remainingLocks.First().TaskNum).FirstOrDefault()
                    : _taskRepository.QueryData(x => x.PalletCode == palletCode).FirstOrDefault();

                if (task == null)
                {
                    return WebResponseContent.Instance.Error("未找到对应的任务信息");
                }
                var firstlocation = _locationInfoService.Db.Queryable<Dt_LocationInfo>().First(x => x.LocationCode == task.SourceAddress);
                decimal totalReturnQty = 0;
                var hasRemainingLocks = remainingLocks.Any(x => x.PalletCode == palletCode);

                // æƒ…况1：处理未分拣的出库锁定记录
                if (hasRemainingLocks)
                {
                    var palletLocks = remainingLocks.Where(x => x.PalletCode == palletCode).ToList();
                    totalReturnQty = palletLocks.Sum(x => x.AssignQuantity - x.PickedQty);

                    if (totalReturnQty > 0)
                    {
                        // åˆ†é…æ–°è´§ä½
                        var newLocation = _locationInfoService.AssignLocation(firstlocation.LocationType);

                        // æ›´æ–°å‡ºåº“锁定记录状态
                        var lockIds = palletLocks.Select(x => x.Id).ToList();
                        await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
                            .SetColumns(it => new Dt_OutStockLockInfo { Status = OutLockStockStatusEnum.回库中.ObjToInt() })
                            .Where(it => lockIds.Contains(it.Id))
                            .ExecuteCommandAsync();

                        // æ›´æ–°æ‹†åŒ…条码记录状态
                        var splitBarcodes = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                            .Where(it => lockIds.Contains(it.OutStockLockInfoId))
                            .ToListAsync();

                        foreach (var splitBarcode in splitBarcodes)
                        {
                            splitBarcode.Status = 3;
                            await _splitPackageService.Db.Updateable(splitBarcode).ExecuteCommandAsync();
                        }

                        // å¤„理库存记录
                        foreach (var lockInfo in palletLocks)
                        {
                            decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                            // æ£€æŸ¥åº“存记录是否存在
                            var existingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                                .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
                                .FirstAsync();

                            if (existingStock != null)
                            {
                                // åº“存记录存在，恢复锁定数量
                                await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
                                    .SetColumns(it => new Dt_StockInfoDetail
                                    {
                                        OutboundQuantity = it.OutboundQuantity - returnQty
                                    })
                                    .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
                                    .ExecuteCommandAsync();
                            }
                            else
                            {
                                // åº“存记录不存在（可能是拆包产生的新条码），创建新的库存记录
                                var newStockDetail = new Dt_StockInfoDetail
                                {
                                    StockId = lockInfo.StockId,
                                    MaterielCode = lockInfo.MaterielCode,
                                    OrderNo = lockInfo.OrderNo,
                                    BatchNo = lockInfo.BatchNo,
                                    StockQuantity = returnQty,
                                    OutboundQuantity = 0,
                                    Barcode = lockInfo.CurrentBarcode,
                                    InboundOrderRowNo = "0",
                                    Status = StockStatusEmun.入库确认.ObjToInt(),

                                };
                                await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
                            }
                        }

                        // åˆ›å»ºå›žåº“任务
                        CreateReturnTask(tasks, task, palletCode, newLocation);
                    }
                }

                // æƒ…况2：出库货物已分拣完，但托盘上还有其他库存货物需要回库
                if (!hasRemainingLocks && palletStockGoods.Any())
                {
                    // åˆ†é…æ–°è´§ä½
                    var newLocation = _locationInfoService.AssignLocation(firstlocation.LocationType);

                    // åˆ›å»ºå›žåº“任务
                    CreateReturnTask(tasks, task, palletCode, newLocation);

                    totalReturnQty = palletStockGoods.Sum(x => x.StockQuantity - x.OutboundQuantity);
                }

                // ä¿å­˜ä»»åŠ¡
                if (tasks.Any())
                {
                    try
                    {
                        await _taskRepository.Db.Insertable(tasks).ExecuteCommandAsync();
                        var targetAddress = task.TargetAddress;
                        _taskRepository.DeleteData(task);
                        // ç»™ ESS æµåŠ¨ä¿¡å·å’Œåˆ›å»ºä»»åŠ¡
                        try
                        {
                            var result = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
                            {
                                slotCode = movestations[targetAddress],
                                containerCode = palletCode
                            });
                            if (result)
                            {
                                TaskModel esstask = new TaskModel()
                                {
                                    taskType = "putaway",
                                    taskGroupCode = "",
                                    groupPriority = 0,
                                    tasks = new List<TasksType>
                                    {
                                        new()
                                        {
                                            taskCode = tasks.First().TaskNum.ToString(),
                                            taskPriority = 0,
                                            taskDescribe = new TaskDescribeType {
                                                containerCode = palletCode,
                                                containerType = "CT_KUBOT_STANDARD",
                                                fromLocationCode = stations.GetValueOrDefault(targetAddress) ?? "",
                                                toStationCode = "",
                                                toLocationCode = tasks.First().TargetAddress,
                                                deadline = 0, storageTag = ""
                                            }
                                        }
                                    }
                                };


                                var resulttask = await _eSSApiService.CreateTaskAsync(esstask);

                                _logger.LogInformation("ReturnRemaining åˆ›å»ºä»»åŠ¡è¿”回:  " + resulttask);
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.LogInformation("ReturnRemaining åˆ›å»ºä»»åŠ¡è¿”回 catch err:  " + ex.Message);

                        }


                        return WebResponseContent.Instance.OK($"回库操作成功，共回库数量：{totalReturnQty}");
                    }
                    catch (Exception ex)
                    {
                        return WebResponseContent.Instance.Error($"创建回库任务失败: {ex.Message}");
                    }
                }

                return WebResponseContent.Instance.Error("未创建任何回库任务");
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"回库操作失败: {ex.Message}");
            }
        }

        /// <summary>
        /// åˆ›å»ºå›žåº“任务
        /// </summary>
        private void CreateReturnTask(List<Dt_Task> tasks, Dt_Task originalTask, string palletCode, Dt_LocationInfo newLocation)
        {
            Dt_Task newTask = new()
            {
                CurrentAddress = stations[originalTask.TargetAddress],
                Grade = 0,
                PalletCode = palletCode,
                NextAddress = "",
                OrderNo = originalTask.OrderNo,
                Roadway = newLocation.RoadwayNo,
                SourceAddress = stations[originalTask.TargetAddress],
                TargetAddress = newLocation.LocationCode,
                TaskStatus = TaskStatusEnum.New.ObjToInt(),
                TaskType = TaskTypeEnum.InPick.ObjToInt(),
                PalletType = originalTask.PalletType,
                WarehouseId = originalTask.WarehouseId,

            };
            tasks.Add(newTask);
        }

        /// <summary>
        /// æ£€æŸ¥æ‰˜ç›˜æ˜¯å¦éœ€è¦å›žåº“的辅助方法
        /// </summary>
        public async Task<bool> CheckPalletNeedReturn(string orderNo, string palletCode)
        {
            // 1. æ£€æŸ¥æ˜¯å¦æœ‰æœªåˆ†æ‹£çš„出库记录
            var hasUnpickedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode && it.Status == 1)
                .AnyAsync();

            if (hasUnpickedLocks)
                return true;

            // 2. æ£€æŸ¥å‡ºåº“是否已完成但托盘还有库存货物
            var outboundFinished = !await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(it => it.PalletCode == palletCode && it.Status == 1)
                .AnyAsync();

            var stockinfo = _stockInfoService.Db.Queryable<Dt_StockInfo>().First(x => x.PalletCode == palletCode);


            var hasRemainingGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .Where(it => it.StockId == stockinfo.Id && it.Status == StockStatusEmun.入库确认.ObjToInt())
                .Where(it => it.OutboundQuantity == 0 || it.OutboundQuantity < it.StockQuantity)
                .AnyAsync();

            return outboundFinished && hasRemainingGoods;
        }

        // å–消拣选功能
        public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)
        {
@@ -338,7 +672,7 @@
                        .Where(x => x.OrderNo == orderNo &&
                                   x.PalletCode == palletCode &&
                                   x.CurrentBarcode == barcode &&
                                   x.Status == 2)
                                   x.Status == 6)
                        .FirstAsync();

                if (outStockInfo == null)
@@ -349,11 +683,15 @@
                outStockInfo.Status = 1;
                await _outStockLockInfoService.Db.Updateable(outStockInfo).ExecuteCommandAsync();

                //// è¿˜åŽŸåº“存出库数量
                //await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
                //        .SetColumns(x => x.OutboundQuantity == x.OutboundQuantity - outStockInfo.AssignQuantity)
                //        .Where(x => x.Barcode == barcode)
                //        .ExecuteCommandAsync();

                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                       .Where(x => x.Barcode == barcode && x.StockId == outStockInfo.StockId)
                       .FirstAsync();
           
                stockDetail.StockQuantity += outStockInfo.AssignQuantity;
                stockDetail.OutboundQuantity += outStockInfo.AssignQuantity;
                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
         

                // è¿˜åŽŸå‡ºåº“单明细
                var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
@@ -377,19 +715,6 @@
                return WebResponseContent.Instance.Error($"取消拣选失败：{ex.Message}");
            }
        }
        /// <summary>
        /// æ ¹æ®æ¡ç æŸ¥æ‰¾é”å®šä¿¡æ¯
        /// </summary>
        private async Task<Dt_OutStockLockInfo> FindLockInfoByBarcode(int orderDetailId, string barcode, string materielCode)
        {
            return await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderDetailId == orderDetailId &&
                           x.MaterielCode == materielCode &&
                           x.CurrentBarcode == barcode &&
                           x.Status == (int)OutLockStockStatusEnum.出库中 &&
                           x.AssignQuantity > x.PickedQty)
                .FirstAsync();
        }

        // èŽ·å–未拣选列表
        public async Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode)
@@ -408,36 +733,17 @@
            var list = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo &&
                           x.PalletCode == palletCode &&
                           x.Status == 2)
                           x.Status == 6)
                .ToListAsync();
            return list;
        }

        public async Task<object> GetPickingSummary(string orderNo, string palletCode)
        {
            var summary = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo &&
                           x.PalletCode == palletCode && x.Status == 1)
                .GroupBy(x => new { x.PalletCode, x.MaterielCode })
                .Select(x => new
                {
                    PalletCode = x.PalletCode,
                    MaterielCode = x.MaterielCode,
                    UnpickedCount = SqlFunc.AggregateCount(x.Id),
                    UnpickedQuantity = SqlFunc.AggregateSum(x.AssignQuantity) - SqlFunc.AggregateSum(x.PickedQty)
                })
                .FirstAsync();

            return summary;
        }

        // èŽ·å–拣选汇总
        public async Task<object> GetPickingSummary(ConfirmPickingDto dto)
        {
            var picked = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
             .WhereIF(!string.IsNullOrEmpty(dto.OrderNo), x => x.OrderNo == dto.OrderNo)
             .WhereIF(!string.IsNullOrEmpty(dto.PalletCode), x => x.PalletCode == dto.PalletCode)
             .Where(x => x.Status == 2)
             .Where(x => x.Status == 6)
             .GroupBy(x => new { x.PalletCode, x.MaterielCode })
             .Select(x => new SummaryPickingDto
             {
@@ -489,88 +795,6 @@
                .ToListAsync();
        }

        public async Task GetPalletPickingSummary(string orderNo, string palletCode)
        {
            var summary = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                .GroupBy(x => new { x.PalletCode, x.Status })
                .Select(x => new
                {
                    PalletCode = x.PalletCode,
                    Status = x.Status,
                    TotalAssignQty = SqlFunc.AggregateSum(x.AssignQuantity),
                    TotalPickedQty = SqlFunc.AggregateSum(x.PickedQty)
                })
                .ToListAsync();

            //   return summary;
        }



        /// <summary>
        /// æ’¤é”€æ‹£é€‰
        /// </summary>
        public async Task<WebResponseContent> CancelPicking(CancelPickingRequest request)
        {
            // å®žçŽ°æ’¤é”€æ‹£é€‰çš„逻辑，需要：
            // 1. æ¢å¤åº“存出库数量
            // 2. æ¢å¤é”å®šä¿¡æ¯çš„已拣选数量
            // 3. æ¢å¤å‡ºåº“单明细的已出数量和锁定数量
            // 4. åˆ é™¤æˆ–标记拣选历史记录
            // æ³¨æ„ï¼šè¿™é‡Œéœ€è¦äº‹åŠ¡å¤„理
            try
            {
                _unitOfWorkManage.BeginTran();

                var pickHistory = await Db.Queryable<Dt_PickingRecord>()
                    .Where(x => x.Id == request.PickingHistoryId)
                    .FirstAsync();

                if (pickHistory == null)
                    return WebResponseContent.Instance.Error("未找到拣选记录");

                // æ¢å¤åº“å­˜
                var stockDetail = await _stockInfoService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == pickHistory.Barcode && x.StockId == pickHistory.StockId)
                    .FirstAsync();
                if (stockDetail != null)
                {
                    stockDetail.OutboundQuantity -= pickHistory.PickQuantity;
                    await _stockInfoService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                }
                // æ¢å¤é”å®šä¿¡æ¯
                var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderDetailId == pickHistory.OrderDetailId && x.StockId == pickHistory.StockId)
                    .FirstAsync();
                lockInfo.PickedQty -= pickHistory.PickQuantity;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // æ¢å¤å‡ºåº“单明细
                var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                    .Where(x => x.Id == pickHistory.OrderDetailId)
                    .FirstAsync();
                orderDetail.OverOutQuantity -= pickHistory.PickQuantity;
                orderDetail.LockQuantity += pickHistory.PickQuantity;
                if (orderDetail.OverOutQuantity < orderDetail.OrderQuantity)
                {
                    orderDetail.OrderDetailStatus = orderDetail.LockQuantity > 0 ?
                        (int)OrderDetailStatusEnum.Outbound : (int)OrderDetailStatusEnum.AssignOverPartial;
                }
                await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

                // åˆ é™¤æ‹£é€‰åŽ†å²è®°å½•
                await Db.Deleteable<Dt_PickingRecord>().Where(x => x.Id == request.PickingHistoryId).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK("撤销成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error($"撤销失败: {ex.Message}");
            }
        }

        /// <summary>
        /// èŽ·å–托盘的出库状态信息
@@ -687,7 +911,7 @@
                    {
                        orderDetail.OverOutQuantity = item.TotalQuantity;
                        orderDetail.LockQuantity = 0;
                        orderDetail.OrderDetailStatus = (int)OrderDetailStatusEnum.Over;                      
                        orderDetail.OrderDetailStatus = (int)OrderDetailStatusEnum.Over;
                        await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
                    }
                }

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_OutboundService/SplitPackageService.cs

@@ -1,4 +1,5 @@
using Microsoft.AspNetCore.Http;
using Org.BouncyCastle.Asn1.Ocsp;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -56,31 +57,61 @@
                    return WebResponseContent.Instance.Error("未找到有效的出库锁定信息");

                // 2. æ£€æŸ¥å‰©ä½™é”å®šæ•°é‡
                decimal remainingLockQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;
                decimal remainingLockQuantity = lockInfo.OriginalQuantity - lockInfo.PickedQty;
                if (request.SplitQuantity > remainingLockQuantity)
                    return WebResponseContent.Instance.Error($"拆包数量不能大于剩余锁定数量，剩余：{remainingLockQuantity}");

                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
               .Where(x => x.Barcode == request.OriginalBarcode)
               .Where(x => x.Barcode == request.OriginalBarcode && x.StockId == lockInfo.StockId)
               .FirstAsync();
                if (stockDetail == null)
                    throw new Exception($"未找到条码{request.OriginalBarcode}对应的库存记录");

                stockDetail.StockQuantity = request.SplitQuantity;
                stockDetail.OutboundQuantity = request.SplitQuantity;
                _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>(stockDetail).ExecuteCommand();


                var seq = await _dailySequenceService.GetNextSequenceAsync();
                // 3. ç”Ÿæˆæ–°æ¡ç 
                string newBarcode = "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0'); 
                string newBarcode = "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0');

                decimal remainingQty = remainingLockQuantity - request.SplitQuantity;

                // ä¸ºæ‹†åŒ…产生的新条码创建库存记录
                var newStockDetail = new Dt_StockInfoDetail
                {
                    SupplyCode = stockDetail.SupplyCode,
                    WarehouseCode = stockDetail.WarehouseCode,
                    BarcodeQty = stockDetail.BarcodeQty,
                    BarcodeUnit = stockDetail.Barcode,
                    BusinessType = stockDetail.BusinessType,
                    Unit = stockDetail.Unit,
                    StockId = lockInfo.StockId,
                    MaterielCode = stockDetail.MaterielCode,
                    OrderNo = stockDetail.OrderNo,
                    BatchNo = stockDetail.BatchNo,
                    StockQuantity = remainingQty,
                    OutboundQuantity = remainingQty, // é”å®šå…¨éƒ¨æ•°é‡
                    Barcode = newBarcode,
                    InboundOrderRowNo = stockDetail.InboundOrderRowNo,

                };
                await _outStockLockInfoService.Db.Insertable(newStockDetail).ExecuteCommandAsync();

                // 4. åˆ›å»ºæ–°çš„出库锁定信息（新条码）
                var newLockInfo = new Dt_OutStockLockInfo
                {
                    

                    OrderNo = lockInfo.OrderNo,
                    OrderDetailId = lockInfo.OrderDetailId,
                    BatchNo = lockInfo.BatchNo,
                    MaterielCode = lockInfo.MaterielCode,
                    MaterielName = lockInfo.MaterielName,
                    StockId = lockInfo.StockId,
                    OrderQuantity = lockInfo.OrderQuantity,
                    OriginalQuantity = lockInfo.OriginalQuantity,
                    AssignQuantity = request.SplitQuantity, // æ–°æ¡ç åˆ†é…æ•°é‡
                    OrderQuantity = remainingQty,
                    OriginalQuantity = remainingQty,
                    AssignQuantity = remainingQty, // æ–°æ¡ç åˆ†é…æ•°é‡
                    PickedQty = 0, // æ–°æ¡ç æœªæ‹£é€‰
                    LocationCode = lockInfo.LocationCode,
                    PalletCode = lockInfo.PalletCode,
@@ -88,7 +119,7 @@
                    Status = (int)OutLockStockStatusEnum.出库中,
                    Unit = lockInfo.Unit,
                    SupplyCode = lockInfo.SupplyCode,
                    OrderType=lockInfo.OrderType,
                    OrderType = lockInfo.OrderType,
                    CurrentBarcode = newBarcode, // æ–°æ¡ç 
                    OriginalLockQuantity = request.SplitQuantity,
                    IsSplitted = 1,
@@ -97,14 +128,14 @@
                await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();

                // 5. æ›´æ–°åŽŸé”å®šä¿¡æ¯çš„分配数量（减少拆包数量）
                lockInfo.AssignQuantity -= request.SplitQuantity;
                lockInfo.AssignQuantity = request.SplitQuantity;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // 6. è®°å½•æ‹†åŒ…历史（用于追踪）
                var splitHistory = new Dt_SplitPackageRecord
                {
                    FactoryArea = lockInfo.FactoryArea,
                    TaskNum=lockInfo.TaskNum,
                    TaskNum = lockInfo.TaskNum,
                    OutStockLockInfoId = lockInfo.Id,
                    StockId = stockDetail?.StockId ?? 0,
                    Operator = App.User.UserName,
@@ -112,7 +143,7 @@
                    OriginalBarcode = lockInfo.CurrentBarcode,
                    NewBarcode = newBarcode,
                    SplitQty = request.SplitQuantity,
                    RemainQuantity = lockInfo.RemainQuantity - request.SplitQuantity,
                    RemainQuantity = lockInfo.OriginalQuantity - request.SplitQuantity,
                    MaterielCode = lockInfo.MaterielCode,
                    SplitTime = DateTime.Now,
                    OrderNo = request.OrderNo,

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -108,7 +108,7 @@
            _outStockLockInfoService = outStockLockInfoService;
        }

 

        /// <summary>
        /// 
        /// </summary>
@@ -119,6 +119,7 @@
            try
            {
                Dt_Task task;

                if (int.TryParse(taskNum, out var newTaskNum))
                {
                    task = BaseDal.QueryFirst(x => x.TaskNum == newTaskNum);
@@ -131,6 +132,7 @@
                {
                    return WebResponseContent.Instance.Error("未找到任务信息");
                }
                _logger.LogInformation($"TaskService TaskCompleted: {JsonConvert.SerializeObject(task)} , {task.TaskType} ");

                MethodInfo? methodInfo = GetType().GetMethod(((TaskTypeEnum)task.TaskType) + "TaskCompleted");
                if (methodInfo != null)
@@ -145,6 +147,7 @@
            }
            catch (Exception ex)
            {
                _logger.LogError($"TaskService TaskCompleted:  {ex.Message} ");
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
@@ -260,15 +263,15 @@

                        };

                        var groupedData = inboundOrder.Details.GroupBy(item => new { item.MaterielCode, item.SupplyCode, item.BatchNo, item.lineNo, item.BarcodeUnit, item.WarehouseCode})
                        var groupedData = inboundOrder.Details.GroupBy(item => new { item.MaterielCode, item.SupplyCode, item.BatchNo, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
                           .Select(group => new FeedbackInboundDetailsModel
                           {
                               materialCode = group.Key.MaterielCode,
                               supplyCode = group.Key.SupplyCode,
                               batchNo = group.Key.BatchNo,
                               lineNo = group.Key.lineNo,
                               warehouseCode = group.Key.WarehouseCode ,
                              // warehouseCode= "1072",
                               warehouseCode = group.Key.WarehouseCode,
                               // warehouseCode= "1072",
                               unit = group.Key.BarcodeUnit,
                               barcodes = group.Select(row => new FeedbackBarcodesModel
                               {
@@ -277,20 +280,51 @@
                               }).ToList()
                           }).ToList();
                        feedmodel.details = groupedData;
                        

                        _invokeMESService.FeedbackInbound(feedmodel);
                    }

                }
            }
            catch (Exception ex) {
            catch (Exception ex)
            {
                _logger.LogInformation("InboundTaskCompleted å›žå†™MES失败:  " + ex.Message);
            }

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent OutboundTaskCompleted(Dt_Task task)
        {
            _logger.LogInformation($"TaskService  OutboundTaskCompleted: {task.TaskNum}");
            //查货位
            Dt_LocationInfo locationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == task.SourceAddress);
            if (locationInfo == null)
            {
                return WebResponseContent.Instance.Error($"未找到对应的终点货位信息");
            }
            locationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
            _locationInfoService.Repository.UpdateData(locationInfo);

            var outloks = _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>().Where(x => x.TaskNum == task.TaskNum).ToList();
            outloks.ForEach(o =>
            {
                o.Status = OutLockStockStatusEnum.已出库.ObjToInt();
            });
            _outStockLockInfoService.Db.Updateable(outloks).ExecuteCommand();

            var locationCodes = outloks.Select(it => it.LocationCode).Distinct().ToList();

            //_stockRepository.Db.Updateable<Dt_StockInfo>()
            //  .SetColumns(it => new Dt_StockInfo { StockStatus = StockStatusEmun.})
            //  .Where(it => locationCodes.Contains(it.LocationCode))
            //  .ExecuteCommand();


            return WebResponseContent.Instance.OK();


        }
        public async Task<WebResponseContent> InEmptyTaskCompleted(Dt_Task task)
        {

@@ -344,14 +378,20 @@
            }
        }

        public  WebResponseContent InPickTaskCompleted(Dt_Task task)
        {
            _logger.LogInformation($"TaskService  InPickTaskCompleted: {task.TaskNum}");


            return WebResponseContent.Instance.OK();
        }

        public async Task<WebResponseContent> OutEmptyTaskCompleted(Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_StockInfo stockInfo = _stockRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == task.PalletCode  ).First();
                Dt_StockInfo stockInfo = _stockRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == task.PalletCode).First();
                if (stockInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到托盘对应的库存信息");
@@ -363,7 +403,7 @@
                    return content.Error($"未找到对应的终点货位信息");
                }

               

                int beforeStatus = locationInfo.LocationStatus;

                locationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
@@ -383,13 +423,14 @@
            }
            catch (Exception ex)
            {
                _logger.LogError($"TaskService OutEmptyTaskCompleted:  {ex.Message} ");
                return await Task.FromResult(WebResponseContent.Instance.Error(ex.Message));
            }
        }



      

        /// <summary>
        /// å›žåº“完成回调 
        public async Task<WebResponseContent> BackToStockComplete(Dt_Task task)
@@ -471,7 +512,7 @@

                //  æ›´æ–°ä»»åŠ¡çŠ¶æ€ä¸ºå·²å®Œæˆ
                task.TaskStatus = (int)TaskStatusEnum.Finish;
             

                await Db.Updateable(task).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService_Outbound.cs

@@ -131,7 +131,7 @@
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_OutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) OutboundTaskDataHandle(int[] keys)
        public (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_OutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) OutboundTaskDataHandle(int[] keys, string outStation)
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            List<Dt_OutboundOrderDetail> outboundOrderDetails = _outboundOrderDetailService.Repository.QueryData(x => keys.Contains(x.Id));
@@ -161,7 +161,7 @@
                        (int)OutOrderTypeEnum.Quality => TaskTypeEnum.OutQuality,
                        _ => new TaskTypeEnum()
                    };
                    tasks = GetTasks(result.Item1, typeEnum);
                    tasks = GetTasks(result.Item1, typeEnum, outStation);
                    tasks.ForEach(x =>
                    {
                        x.OrderNo = outboundOrder.OrderNo;
@@ -304,7 +304,7 @@
        /// </summary>
        /// <param name="stockInfos"></param>
        /// <returns></returns>
        public List<Dt_Task> GetTasks(List<Dt_StockInfo> stockInfos, TaskTypeEnum taskType)
        public List<Dt_Task> GetTasks(List<Dt_StockInfo> stockInfos, TaskTypeEnum taskType, string outStation)
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            List<Dt_LocationInfo> locationInfos = _locationInfoService.Repository.QueryData(x => stockInfos.Select(x => x.LocationCode).Contains(x.LocationCode));
@@ -325,7 +325,7 @@
                            NextAddress = "",
                            Roadway = locationInfo.RoadwayNo,
                            SourceAddress = stockInfo.LocationCode,
                            TargetAddress = "",
                            TargetAddress = outStation,
                            TaskStatus = TaskStatusEnum.New.ObjToInt(),
                            TaskType = taskType.ObjToInt(),
                            // TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
@@ -353,7 +353,7 @@
        /// </summary>
        /// <param name="keys">出库单明细主键</param>
        /// <returns></returns>
        public async Task<WebResponseContent> GenerateOutboundTasksAsync(int[] keys)
        public async Task<WebResponseContent> GenerateOutboundTasksAsync(int[] keys,string outStation) 
        {
            try
            {
@@ -364,7 +364,7 @@
                List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
                List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_OutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = OutboundTaskDataHandle(keys);
                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_OutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = OutboundTaskDataHandle(keys,outStation);
                if (result.Item2 != null && result.Item2.Count > 0)
                {
                    stockInfos.AddRange(result.Item2);

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Outbound/OutboundOrderController.cs

@@ -2,6 +2,7 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using WIDESEA_Core;
using WIDESEA_Core.Attributes;
using WIDESEA_Core.BaseController;
@@ -10,6 +11,7 @@
using WIDESEA_DTO.Outbound;
using WIDESEA_IOutboundService;
using WIDESEA_Model.Models;
using WIDESEA_WMSServer.Controllers.Inbound;

namespace WIDESEA_WMSServer.Controllers.Outbound
{
@@ -20,9 +22,10 @@
    [ApiController]
    public class OutboundOrderController : ApiBaseController<IOutboundOrderService, Dt_OutboundOrder>
    {
        public OutboundOrderController(IOutboundOrderService service) : base(service)
        private readonly ILogger<OutboundOrderController> _logger;
        public OutboundOrderController(IOutboundOrderService service, ILogger<OutboundOrderController> logger) : base(service)
        {

            _logger = logger;
        }
        /// <summary>
        /// æŽ¥æ”¶MES出库单信息
@@ -32,6 +35,7 @@
        [HttpPost, Route("ReceiveOutBoundOrder"), AllowAnonymous, MethodParamsValidate]
        public WebResponseContent ReceiveOutBoundOrder([FromBody] OutboundRequestModel model)
        {
            _logger.LogInformation("OutboundOrderController ReceiveOutBoundOrder:  " + JsonConvert.SerializeObject(model));
            Dt_OutboundOrder dt_OutboundOrder = new Dt_OutboundOrder() { Details = new List<Dt_OutboundOrderDetail>() };
            foreach (var detailitem in model.details)
            {

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Outbound/OutboundPickingController.cs

@@ -1,4 +1,5 @@
using Microsoft.AspNetCore.Http;
using Autofac.Core;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
@@ -92,10 +93,9 @@


        [HttpPost("return-to-stock")]
        public async Task<WebResponseContent> ReturnToStock( )
        public async Task<WebResponseContent> ReturnToStock([FromBody] ConfirmPickingDto dto)
        {
            var data= "";
            return WebResponseContent.Instance.OK("", data);
            return await Service.ReturnRemaining(dto.OrderNo, dto.PalletCode, "");
        }

        [HttpPost("direct-outbound")]

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/TaskInfo/TaskController.cs

@@ -42,9 +42,9 @@
        /// <param name="keys"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("GenerateOutboundTasks"), AllowAnonymous]
        public async Task<WebResponseContent> GenerateOutboundTasks([FromBody] int[] keys)
        public async Task<WebResponseContent> GenerateOutboundTasks([FromBody] GenerateOutboundTasksDto data)
        {
            return await Service.GenerateOutboundTasksAsync(keys);
            return await Service.GenerateOutboundTasksAsync(data.taskIds,data.outboundPlatform);
        }

    }