ÏîÄ¿´úÂë/WIDESEA_WMSClient/src/extension/outbound/outboundOrder.js

@@ -314,6 +314,13 @@
              );
          },
          click: (row) => {
            const table = this.$refs.table.$refs.table;
            if(table){
              table.clearSelection();
              table.toggleRowSelection(row,true);
            }
              const rowId =row.id;
              console.log(rowId);
              this.$refs.gridBody.open(row);
          }
      });

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

@@ -1068,12 +1068,15 @@
        if (res.status) {
          this.$message.success('拆包成功');
          this.showSplitDialog = false;
              this.splitLoading = false;
          this.resetSplitForm();
          this.loadData();
        } else {
               this.splitLoading = false;
          this.$message.error(res.message || '拆包失败');
        }
      } catch (error) {
             this.splitLoading = false;
        this.$message.error('拆包失败');
      }
    },
@@ -1121,12 +1124,15 @@
        if (res.status) {
          this.$message.success('撤销拆包成功');
          this.showRevertSplitDialog = false;
           this.revertSplitLoading = false;
          this.revertSplitForm.originalBarcode = '';
          this.loadData();
        } else {
         this.revertSplitLoading = false;
          this.$message.error(res.message || '撤销拆包失败');
        }
      } catch (error) {
         this.revertSplitLoading = false;
        this.$message.error('撤销拆包失败');
      }
    },

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

@@ -64,7 +64,7 @@
            return JsonConvert.DeserializeObject<ResponseModel>(body);
        }

        public async Task FeedbackOutbound(FeedbackOutboundRequestModel model)
        public async Task<ResponseModel> FeedbackOutbound(FeedbackOutboundRequestModel model)
        {
            string json = JsonConvert.SerializeObject(model, new JsonSerializerSettings
            {
@@ -75,6 +75,8 @@
            _client.DefaultRequestHeaders.Clear();
            _client.DefaultRequestHeaders.Add("Accept", "application/json");

            _logger.LogInformation("InvokeMESService  FeedbackOutbound :  " + json);

            var response = await _client.PostAsync("AldMaterialOutbound/MaterialOutbound", content);
            string body = await response.Content.ReadAsStringAsync();

@@ -84,7 +86,8 @@
                throw new HttpRequestException(body);
            }

            // JsonConvert.DeserializeObject<ResponseModel>(body);

            return JsonConvert.DeserializeObject<ResponseModel>(body);
        }

        public async Task<ResponseModel> NewMaterielToMes(MaterielToMesDTO model)
@@ -113,7 +116,9 @@

            var content = new StringContent(json, Encoding.UTF8, "application/json");

            using var response = await client.PostAsync("", content);
            _logger.LogInformation("InvokeMESService  FeedbackInbound :  " + json);

            using var response = await client.PostAsync("AldBarcodeInformation/BarcodeInformation", content);
            var responseText = await response.Content.ReadAsStringAsync();
            if (!response.IsSuccessStatusCode)
            {
@@ -214,6 +219,7 @@
                                           supplyCode = group.Key.SupplyCode,
                                           batchNo = group.Key.BatchNo,
                                           lineNo = group.Key.InboundOrderRowNo,
                                           qty = group.Sum(x=>x.BarcodeQty),
                                           // warehouseCode = group.Key.WarehouseCode=="0"?"1072": group.Key.WarehouseCode,
                                           warehouseCode =group.Key.WarehouseCode,
                                           unit = group.Key.BarcodeUnit,

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

@@ -9,6 +9,7 @@
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Outbound;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;
using WIDESEA_Model.Models.Basic;
@@ -17,10 +18,11 @@
{
    internal class MaterielToMesService : ServiceBase<Dt_MaterielToMes, IRepository<Dt_MaterielToMes>>, IMaterielToMesService
    {
     
        public MaterielToMesService(IRepository<Dt_MaterielToMes> BaseDal ) : base(BaseDal)
        private readonly IInvokeMESService _invokeMESService;

        public MaterielToMesService(IRepository<Dt_MaterielToMes> BaseDal, IInvokeMESService invokeMESService) : base(BaseDal)
        {
            
            _invokeMESService = invokeMESService;
        }
        // åˆ›å»ºä¸€ä¸ªä½¿ç”¨å°é©¼å³°å‘½åæ³•çš„序列化设置
        JsonSerializerSettings settings = new JsonSerializerSettings
@@ -35,9 +37,11 @@
            WebResponseContent content = base.AddData(saveModel);
            if (content.Status)
            {
 

                string request = JsonConvert.SerializeObject(saveModel, settings);
                var url = AppSettings.GetValue("MESUrl").ObjToString();
                string response = HttpHelper.Post( url+"", request);
             

                return WebResponseContent.Instance.OK();
            }
            else

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

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
@@ -11,5 +12,58 @@
        æ™ºä»“调智仓=1,
        æ™ºä»“调外部仓库=2,
        å¤–部仓库调智仓=3
    } 
    public enum MESDocumentType
    {
        /// <summary>采购入库（入库类型）</summary>
        [Description("采购入库")]
        
        PurchaseInbound = 11,

        /// <summary>杂收单（入库类型）</summary>
        [Description("杂收单")]
        
        MiscellaneousInbound = 12,

        /// <summary>生产退料单（入库类型）</summary>
        [Description("生产退料单")]
        
        ProductionReturn = 13,

        /// <summary>外协退料单（入库类型）</summary>
        [Description("外协退料单")]
        
        OutsourcingReturn = 14,

        /// <summary>销售退库单（入库类型）</summary>
        [Description("销售退库单")]
        
        SalesReturn = 15,

        /// <summary>工单领料单申请单（出库类型）</summary>
        [Description("工单领料单申请单")]
        
        WorkOrderMaterialRequest = 21,

        /// <summary>杂发单（出库类型）</summary>
        [Description("杂发单")]
        
        MiscellaneousOutbound = 22,

        /// <summary>退货单（出库类型）</summary>
        [Description("退货单")]
        
        ReturnOrder = 23,

        /// <summary>销售出库单（出库类型）</summary>
        [Description("销售出库单")]
        
        SalesOutbound = 24,

        /// <summary>外协领料申请单（出库类型）</summary>
        [Description("外协领料申请单")]
        
        OutsourcingMaterialRequest = 25
    }

}

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

@@ -912,8 +912,8 @@
                        _db.InsertableByObject(obj).AS(type.Name + "_Hty").ExecuteCommand();
                }
            }
            // return DeleteData(entity);
            return true;
            return DeleteData(entity);
           
        }

        public bool DeleteAndMoveIntoHty(List<TEntity> entities, OperateTypeEnum operateType)

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

@@ -26,7 +26,7 @@
        public string newmaterialCode { get; set; }
        public string unit { get; set; }
        public string factoryArea { get; set; }
        public string qty { get; set; }
        public decimal qty { get; set; }
        public string supplyCode { get; set; }
        public string warehouseCode { get; set; }
        public string batchNo { get; set; }

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

@@ -97,7 +97,7 @@
        public int status { get; set; }

        public string factoryArea { get; set; }

        public string Operator { get; set; }
        public List<FeedbackOutboundDetailsModel> details { get; set; }

    }

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

@@ -14,12 +14,11 @@
    {
        Task<ResponseModel> FeedbackInbound(FeedbackInboundRequestModel model);

        Task FeedbackOutbound(FeedbackOutboundRequestModel model);
        Task<ResponseModel> FeedbackOutbound(FeedbackOutboundRequestModel model);

        Task<string> GetToken(String username, string password);

        Task<ResponseModel> NewMaterielToMes(MaterielToMesDTO model);


        Task<WebResponseContent> BatchOrderFeedbackToMes(List<string> orderNos, int inout);
    }

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

@@ -22,7 +22,7 @@

        WebResponseContent LockOutboundStockDataUpdate(List<Dt_StockInfo> stockInfos, List<Dt_OutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null);


        //List<Dt_OutboundOrderDetail> GetOutboundStockDataById(int id);

    }
}

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

@@ -109,6 +109,10 @@
        public int? TaskNum { get; set; }

        public string SupplyCode { get; set; }

        [SugarColumn(ColumnName = "lineNo", ColumnDescription = "行号")]
        public string? lineNo { get; set; }

        public string WarehouseCode { get; set; }
        /// <summary>
        /// çŠ¶æ€ çŠ¶æ€ï¼š0-已分配  1-出库中 2-部分拣选  3已拣选  

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

@@ -84,7 +84,8 @@

            return new Dt_OutStockLockInfo()
            {

                lineNo= outboundOrderDetail.lineNo,
               
                PalletCode = outStock.PalletCode,
                AssignQuantity = assignQuantity,
                MaterielCode = outboundOrderDetail.MaterielCode,

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

@@ -1,9 +1,12 @@
using Microsoft.Extensions.Logging;
using SqlSugar;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Stock;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
@@ -255,5 +258,35 @@
            }
        }



        public override PageGridData<Dt_OutboundOrderDetail> GetPageData(PageDataOptions options)
        {
            //var  pageGridData = base.GetPageData(options);

            ISugarQueryable<Dt_OutboundOrderDetail> sugarQueryable1 = BaseDal.Db.Queryable<Dt_OutboundOrderDetail>();
            if (!string.IsNullOrEmpty(options.Wheres))
            {

                List<SearchParameters> searchParametersList = options.Wheres.DeserializeObject<List<SearchParameters>>();
                int totalCount = 0;
                if (searchParametersList.Count > 0)
                {
                    {
                        SearchParameters? searchParameters = searchParametersList.FirstOrDefault(x => x.Name == nameof(Dt_InboundOrderDetail.OrderId).FirstLetterToLower());
                        if (searchParameters != null)
                        {
                            sugarQueryable1 = sugarQueryable1.Where(x => x.OrderId== searchParameters.Value.ObjToInt());
                            var  dataList = sugarQueryable1.ToPageList(options.Page, options.Rows, ref totalCount);
                            return new PageGridData<Dt_OutboundOrderDetail>(totalCount, dataList);
                        }
                    }

                   
                }
            }
            return new PageGridData<Dt_OutboundOrderDetail> ();
        }

    }
}

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

@@ -17,6 +17,7 @@
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Outbound;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundService;
@@ -43,7 +44,7 @@
        private readonly ISplitPackageService _splitPackageService;
        private readonly IRepository<Dt_Task> _taskRepository;
        private readonly IESSApiService _eSSApiService;

        private readonly IInvokeMESService _invokeMESService;

        private readonly ILogger<OutboundPickingService> _logger;

@@ -61,7 +62,7 @@

        };

        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)
        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, IInvokeMESService invokeMESService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
@@ -75,6 +76,7 @@
            _taskRepository = taskRepository;
            _eSSApiService = eSSApiService;
            _logger = logger;
            _invokeMESService = invokeMESService;
        }


@@ -177,6 +179,12 @@
                if (lockInfo.PalletCode != palletCode)
                    throw new Exception($"条码{barcode}不属于托盘{palletCode}");

                var outorderdetail = _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().First(x => x.Id == lockInfo.OrderDetailId);
                if (outorderdetail != null && lockInfo.AssignQuantity > outorderdetail.OrderQuantity)
                {
                    throw new Exception($"条码{barcode}的出库数量大于订单的数量");
                }

                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .Where(x => x.Barcode == barcode && x.StockId == lockInfo.StockId)
                        .FirstAsync();
@@ -248,10 +256,15 @@
        private async Task CheckAndUpdateOrderStatus(string orderNo)
        {

            var orderDetails = _stockInfoDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                      .LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id) // å…³è”条件：父表 Id = å­è¡¨ OrderId
                      .Where((o, item) => item.OrderNo == orderNo) // è¿‡æ»¤çˆ¶è¡¨ OrderNo
                      .Select((o, item) => o) // åªè¿”回子表数据
                      .ToList();

            var orderDetails = await _stockInfoDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .Where(x => x.OrderId == orderNo.ObjToInt())
                .ToListAsync();
            //var orderDetails = await _stockInfoDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
            //    .Where(x => x.OrderId == orderNo.ObjToInt())
            //    .ToListAsync();

            bool allCompleted = true;
            foreach (var detail in orderDetails)
@@ -265,10 +278,60 @@

            if (allCompleted)
            {
                await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                    .SetColumns(x => x.OrderStatus == 2) // å·²å®Œæˆ
                    .Where(x => x.OrderNo == orderNo)
                    .ExecuteCommandAsync();
                try
                {
                    await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                        .SetColumns(x => x.OrderStatus == 2) // å·²å®Œæˆ
                        .Where(x => x.OrderNo == orderNo)
                        .ExecuteCommandAsync();

                    var outboundOrder = _stockInfoService.Db.Queryable<Dt_OutboundOrder>().First(x => x.OrderNo == orderNo);


                    if (outboundOrder != null && outboundOrder.OrderStatus == InOrderStatusEnum.入库完成.ObjToInt())
                    {
                        var feedmodel = new FeedbackOutboundRequestModel
                        {
                            reqCode = Guid.NewGuid().ToString(),
                            reqTime = DateTime.Now.ToString(),
                            business_type = outboundOrder.BusinessType,
                            factoryArea = outboundOrder.FactoryArea,
                            operationType = 1,
                            Operator = outboundOrder.Operator,
                            orderNo = outboundOrder.UpperOrderNo,
                            status = outboundOrder.OrderStatus,
                            details = new List<FeedbackOutboundDetailsModel>()

                        };
                        var lists = _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>().Where(x => x.OrderNo == orderNo).ToList();

                        var groupedData = lists.GroupBy(item => new { item.MaterielCode, item.lineNo, item.Unit, item.WarehouseCode })
                           .Select(group => new FeedbackOutboundDetailsModel
                           {
                               materialCode = group.Key.MaterielCode,
                               lineNo = group.Key.lineNo,
                               warehouseCode = group.Key.WarehouseCode,
                               currentDeliveryQty = group.Sum(x => x.OrderQuantity),
                               // warehouseCode= "1072",
                               unit = group.Key.Unit,
                               barcodes = group.Select(row => new WIDESEA_DTO.Outbound.BarcodesModel
                               {
                                   barcode = row.CurrentBarcode,
                                   supplyCode = row.SupplyCode,
                                   batchNo = row.BatchNo,
                                   unit = row.Unit,
                                   qty = row.AssignQuantity
                               }).ToList()
                           }).ToList();
                          feedmodel.details = groupedData;

                        _invokeMESService.FeedbackOutbound(feedmodel);
                    }
                }
                catch (Exception ex) {
                    _logger.LogError(" OutboundPickingService  FeedbackOutbound : " + ex.Message);
                }
                 
            }
        }

@@ -276,165 +339,18 @@
        /// <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>();

@@ -447,6 +363,21 @@
                {
                    return WebResponseContent.Instance.Error("未找到对应的任务信息");
                }

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

                //  å¦‚果没有需要回库的货物（既无未分拣出库货物，也无其他库存货物）
                if (!remainingLocks.Any() && !palletStockGoods.Any())
                {
                    //是否自动回库，把之前出库的任务删除，然后组个空盘入库。
                    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);
@@ -687,11 +618,11 @@
                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>()
@@ -699,6 +630,7 @@
                    .FirstAsync();

                orderDetail.OverOutQuantity -= outStockInfo.AssignQuantity;
                orderDetail.PickedQty = 0;
                await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

                // åˆ é™¤æ‹£é€‰åŽ†å²

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

@@ -1,4 +1,5 @@
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Org.BouncyCastle.Asn1.Ocsp;
using System;
using System.Collections.Generic;
@@ -9,6 +10,7 @@
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Outbound;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundService;
@@ -26,14 +28,18 @@
        private readonly IStockInfoDetailService _stockInfoDetailService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly IDailySequenceService _dailySequenceService;
        private readonly IInvokeMESService _invokeMESService;

        public SplitPackageService(IRepository<Dt_SplitPackageRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, IDailySequenceService dailySequenceService) : base(BaseDal)
        private readonly ILogger<SplitPackageService> _logger;
        public SplitPackageService(IRepository<Dt_SplitPackageRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, IDailySequenceService dailySequenceService, IInvokeMESService invokeMESService, ILogger<SplitPackageService> logger) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
            _outStockLockInfoService = outStockLockInfoService;
            _stockInfoDetailService = stockInfoDetailService;
            _dailySequenceService = dailySequenceService;
            _invokeMESService = invokeMESService;
            _logger = logger;
        }

        /// <summary>
@@ -84,7 +90,7 @@
                    SupplyCode = stockDetail.SupplyCode,
                    WarehouseCode = stockDetail.WarehouseCode,
                    BarcodeQty = stockDetail.BarcodeQty,
                    BarcodeUnit = stockDetail.Barcode,
                    BarcodeUnit = stockDetail.BarcodeUnit,
                    BusinessType = stockDetail.BusinessType,
                    Unit = stockDetail.Unit,
                    StockId = lockInfo.StockId,
@@ -153,10 +159,30 @@
                await Db.Insertable(splitHistory).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();

                // 7. å›žä¼ æ–°æ¡ç ç»™MES
                // await SendBarcodeToMES(newBarcode, request.MaterielCode, request.SplitQuantity);

                              
                try
                {
                    MaterielToMesDTO dto = new MaterielToMesDTO
                    {
                        batchNo = stockDetail.BatchNo,
                        factoryArea = stockDetail.FactoryArea,
                        materialCode = stockDetail.MaterielCode,
                        newmaterialCode = newBarcode,
                        oldmaterialCode = request.OriginalBarcode,
                        operationType = 1,
                        qty = remainingQty,
                        supplyCode = stockDetail.SupplyCode,
                        unit = stockDetail.BarcodeUnit,
                        warehouseCode = stockDetail.WarehouseCode,
                        reqCode = Guid.NewGuid().ToString(),
                        reqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
                    };
                    _invokeMESService.NewMaterielToMes(dto);
                }
                catch(Exception ex)
                {
                    _logger.LogError("SplitPackage å›žä¼ MES:  " + ex.Message);
                }
                return WebResponseContent.Instance.OK("拆包成功", new
                {
                    NewBarcode = newBarcode,
@@ -170,48 +196,180 @@
            }
        }

        // æ’¤é”€æ‹†åŒ…
 
        //public async Task<WebResponseContent> RevertSplitPackage(string originalBarcode)
        //{
        //    try
        //    {
        //        _unitOfWorkManage.BeginTran();

        //        // 1. æŸ¥æ‰¾æœ€è¿‘的未撤销拆包记录
        //        var splitRecord = await Db.Queryable<Dt_SplitPackageRecord>()
        //                .Where(x => x.OriginalBarcode == originalBarcode && !x.IsReverted)
        //                .OrderByDescending(x => x.SplitTime)
        //                .FirstAsync();

        //        if (splitRecord == null)
        //            return WebResponseContent.Instance.Error("未找到可撤销的拆包记录");

        //        // 2. æ£€æŸ¥æ–°æ¡ç æ˜¯å¦å·²æ‹£é€‰
        //        var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
        //            .Where(x => x.CurrentBarcode == splitRecord.NewBarcode)
        //            .FirstAsync();

        //        if (newLockInfo?.Status ==6) // å‡è®¾çŠ¶æ€2表示已拣选
        //            return WebResponseContent.Instance.Error("新条码已拣选，无法撤销拆包");

        //        // 3. èŽ·å–原条码的锁定信息
        //        var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
        //            .Where(x => x.CurrentBarcode == originalBarcode)
        //            .FirstAsync();

        //        if (originalLockInfo == null)
        //            return WebResponseContent.Instance.Error("未找到原条码锁定信息");

          
        //        originalLockInfo.AssignQuantity  += splitRecord.RemainQuantity;  
        //       // originalLockInfo.Status = (int)OutLockStockStatusEnum.出库中;
        //        originalLockInfo.IsSplitted = 0; // æ ‡è®°ä¸ºæœªæ‹†åŒ…
        //        await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();

        //        // 5. è¿˜åŽŸåŽŸæ¡ç åº“存记录
        //        var originalStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
        //            .Where(x => x.Barcode == originalBarcode && x.StockId == splitRecord.StockId)
        //            .FirstAsync();

        //        if (originalStockDetail != null)
        //        {
        //            // å°†æ‹†å‡ºçš„数量加回到原条码库存
        //            originalStockDetail.StockQuantity += splitRecord.RemainQuantity;
        //            originalStockDetail.OutboundQuantity += splitRecord.RemainQuantity;
        //            await _stockInfoDetailService.Db.Updateable(originalStockDetail).ExecuteCommandAsync();
        //        }

        //        // 6. åˆ é™¤æ–°æ¡ç çš„锁定信息
        //        if (newLockInfo != null)
        //        {
        //            await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
        //                .Where(x => x.CurrentBarcode == splitRecord.NewBarcode)
        //                .ExecuteCommandAsync();
        //        }

        //        // 7. åˆ é™¤æ–°æ¡ç çš„库存记录
        //        var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
        //            .Where(x => x.Barcode == splitRecord.NewBarcode)
        //            .FirstAsync();

        //        if (newStockDetail != null)
        //        {
        //            await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
        //                .Where(x => x.Barcode == splitRecord.NewBarcode)
        //                .ExecuteCommandAsync();
        //        }

        //        // 8. æ›´æ–°æ‹†åŒ…记录为已撤销
        //        splitRecord.IsReverted = true;              
        
        //        await Db.Updateable(splitRecord).ExecuteCommandAsync();

        //        _unitOfWorkManage.CommitTran();

        //        return WebResponseContent.Instance.OK($"撤销拆包成功，还原数量：{splitRecord.SplitQty}");

        //    }
        //    catch (Exception ex)
        //    {
        //        _unitOfWorkManage.RollbackTran();
        //        return WebResponseContent.Instance.Error($"撤销拆包失败：{ex.Message}");
        //    }
        //}
 
        public async Task<WebResponseContent> RevertSplitPackage(string originalBarcode)
        {
            try
            {
                _unitOfWorkManage.BeginTran();
                // æŸ¥æ‰¾æœ€è¿‘的未撤销拆包记录
                var splitPackage = await Db.Queryable<Dt_SplitPackageRecord>()

                // 1. æŸ¥æ‰¾æ‰€æœ‰æœªæ’¤é”€çš„拆包记录
                var splitRecords = await Db.Queryable<Dt_SplitPackageRecord>()
                        .Where(x => x.OriginalBarcode == originalBarcode && !x.IsReverted)
                        .OrderByDescending(x => x.CreateDate)
                        .FirstAsync();
                        .OrderBy(x => x.SplitTime) // æŒ‰æ—¶é—´æ­£åºï¼Œä»Žæœ€æ—©å¼€å§‹æ’¤é”€
                        .ToListAsync();

                if (splitPackage == null)
                    return WebResponseContent.Instance.Error("未找到拆包记录");
                if (splitRecords == null || !splitRecords.Any())
                    return WebResponseContent.Instance.Error("未找到可撤销的拆包记录");

                // æ£€æŸ¥æ–°æ¡ç æ˜¯å¦å·²æ‹£é€‰
                var newOutStockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == splitPackage.NewBarcode)
                    .FirstAsync();
                // 2. æ£€æŸ¥æ‰€æœ‰æ–°æ¡ç æ˜¯å¦å·²æ‹£é€‰
                var newBarcodes = splitRecords.Select(x => x.NewBarcode).ToList();
                var newLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => newBarcodes.Contains(x.CurrentBarcode))
                    .ToListAsync();

                if (newOutStockInfo.Status == 2)
                    return WebResponseContent.Instance.Error("新条码已拣选，无法撤销拆包");
                var pickedBarcodes = newLockInfos.Where(x => x.Status == 2).Select(x => x.CurrentBarcode).ToList();
                if (pickedBarcodes.Any())
                    return WebResponseContent.Instance.Error($"以下条码已拣选，无法撤销：{string.Join(",", pickedBarcodes)}");

                // è¿˜åŽŸåŽŸå‡ºåº“详情数量
                var originalOutStockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                // 3. èŽ·å–原条码信息
                var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == originalBarcode)
                    .FirstAsync();

                originalOutStockInfo.AssignQuantity += splitPackage.SplitQty;
                await _outStockLockInfoService.Db.Updateable(originalOutStockInfo).ExecuteCommandAsync();
                if (originalLockInfo == null)
                    return WebResponseContent.Instance.Error("未找到原条码锁定信息");

                // åˆ é™¤æ–°å‡ºåº“详情记录
                var originalStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == originalBarcode && x.StockId == originalLockInfo.StockId)
                    .FirstAsync();

                // 4. èŽ·å–所有新条码的库存记录
                var newStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => newBarcodes.Contains(x.Barcode))
                    .ToListAsync();

                // 5. è®¡ç®—总还原数量
                decimal totalRevertQty = newStockDetails.Sum(x => x.StockQuantity);

                // 6. è¿˜åŽŸåŽŸæ¡ç åº“存记录
                if (originalStockDetail != null)
                {
                    // åŽŸæ¡ç å½“前数量加上所有新条码的数量
                    originalStockDetail.StockQuantity += totalRevertQty;
                    originalStockDetail.OutboundQuantity += totalRevertQty;
                    await _stockInfoDetailService.Db.Updateable(originalStockDetail).ExecuteCommandAsync();
                }

                // 7. è¿˜åŽŸåŽŸæ¡ç é”å®šä¿¡æ¯
                decimal totalAssignQty = newLockInfos.Sum(x => x.AssignQuantity);
                originalLockInfo.AssignQuantity += totalAssignQty;
                if (originalLockInfo.OrderQuantity < originalLockInfo.AssignQuantity)
                {
                    originalLockInfo.AssignQuantity=originalLockInfo.OrderQuantity;
                }
                originalLockInfo.Status = (int)OutLockStockStatusEnum.出库中;
                originalLockInfo.IsSplitted = 0;
                await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();

                // 8. åˆ é™¤æ‰€æœ‰æ–°æ¡ç çš„锁定信息
                await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == splitPackage.NewBarcode)
                    .Where(x => newBarcodes.Contains(x.CurrentBarcode))
                    .ExecuteCommandAsync();

                // æ ‡è®°æ‹†åŒ…记录为已撤销
                splitPackage.IsReverted = true;
                await Db.Updateable(splitPackage).ExecuteCommandAsync();
                // 9. åˆ é™¤æ‰€æœ‰æ–°æ¡ç çš„库存记录
                await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => newBarcodes.Contains(x.Barcode))
                    .ExecuteCommandAsync();

                // 10. æ ‡è®°æ‰€æœ‰æ‹†åŒ…记录为已撤销
                foreach (var record in splitRecords)
                {
                    record.IsReverted = true;
              
                }
                await Db.Updateable(splitRecords).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK("撤销拆包成功");

                return WebResponseContent.Instance.OK($"撤销拆包成功，共还原{splitRecords.Count}次拆包，总数量：{totalRevertQty}");

            }
            catch (Exception ex)
@@ -220,7 +378,6 @@
                return WebResponseContent.Instance.Error($"撤销拆包失败：{ex.Message}");
            }
        }

        // èŽ·å–拆包信息
        public async Task<WebResponseContent> GetSplitPackageInfo(string orderNo, string palletCode, string barcode)
        {

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

@@ -16,6 +16,7 @@
#endregion << ç‰ˆ æœ¬ æ³¨ é‡Š >>

using AutoMapper;
using Dm.filter;
using MailKit.Search;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
@@ -271,6 +272,7 @@
                               batchNo = group.Key.BatchNo,
                               lineNo = group.Key.lineNo,
                               warehouseCode = group.Key.WarehouseCode,
                               qty=group.Sum(x=>x.BarcodeQty),
                               // warehouseCode= "1072",
                               unit = group.Key.BarcodeUnit,
                               barcodes = group.Select(row => new FeedbackBarcodesModel
@@ -307,18 +309,25 @@
            _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();
            var stockids = outloks.Select(x => x.StockId).ToList();
            
            _stockService.StockInfoService.Db.Updateable<Dt_StockInfo>()
                                  .SetColumns(it => new Dt_StockInfo
                                  {
                                      StockStatus = StockStatusEmun.出库锁定.ObjToInt()
                                  })
                                  .Where(it => stockids.Contains(it.Id))
                                  .ExecuteCommand();

            //_stockRepository.Db.Updateable<Dt_StockInfo>()
            //  .SetColumns(it => new Dt_StockInfo { StockStatus = StockStatusEmun.})
            //  .Where(it => locationCodes.Contains(it.LocationCode))
            //  .ExecuteCommand();
            _stockService.StockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
                                  .SetColumns(it => new Dt_StockInfoDetail
                                  {
                                      Status = StockStatusEmun.出库锁定.ObjToInt()
                                  })
                                  .Where(it => stockids.Contains( it.StockId))
                                  .ExecuteCommand();
 


            return WebResponseContent.Instance.OK();
@@ -378,10 +387,48 @@
            }
        }

        public  WebResponseContent InPickTaskCompleted(Dt_Task task)
        public WebResponseContent InPickTaskCompleted(Dt_Task task)
        {
            _logger.LogInformation($"TaskService  InPickTaskCompleted: {task.TaskNum}");
            //查库存
            Dt_StockInfo stockInfo = _stockRepository.Db.Queryable<Dt_StockInfo>().Includes(x => x.Details).Where(x => x.PalletCode == task.PalletCode).First();
            if (stockInfo == null)
            {
                return WebResponseContent.Instance.Error($"未找到托盘对应的组盘信息");
            }
            if (stockInfo.Details.Count == 0 && stockInfo.PalletType != PalletTypeEnum.Empty.ObjToInt())
            {
                return WebResponseContent.Instance.Error($"未找到该托盘库存明细信息");
            }

            //查货位
            Dt_LocationInfo locationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            if (locationInfo == null)
            {
                return WebResponseContent.Instance.Error($"未找到对应的终点货位信息");
            }
            stockInfo.LocationCode = task.TargetAddress;
            stockInfo.StockStatus = StockStatusEmun.入库完成.ObjToInt();
            stockInfo.Details.ForEach(x =>
            {
                x.Status = StockStatusEmun.入库完成.ObjToInt();
            });
            _stockService.StockInfoService.Repository.UpdateData(stockInfo);
            _stockService.StockInfoDetailService.Repository.UpdateData(stockInfo.Details);

            if (stockInfo.PalletType == PalletTypeEnum.Empty.ObjToInt())
            {
                locationInfo.LocationStatus = LocationStatusEnum.Pallet.ObjToInt();
            }
            else
            {
                locationInfo.LocationStatus = LocationStatusEnum.InStock.ObjToInt();
            }
            _locationInfoService.Repository.UpdateData(locationInfo);

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

            BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);

            return WebResponseContent.Instance.OK();
        }

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

@@ -159,7 +159,7 @@
                        (int)OutOrderTypeEnum.Issue => TaskTypeEnum.Outbound,
                        (int)OutOrderTypeEnum.Allocate => TaskTypeEnum.OutAllocate,
                        (int)OutOrderTypeEnum.Quality => TaskTypeEnum.OutQuality,
                        _ => new TaskTypeEnum()
                        _ =>   TaskTypeEnum.Outbound 
                    };
                    tasks = GetTasks(result.Item1, typeEnum, outStation);
                    tasks.ForEach(x =>

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

@@ -1,8 +1,11 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using WIDESEA_Core;
using WIDESEA_Core.Attributes;
using WIDESEA_Core.BaseController;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Stock;
using WIDESEA_IOutboundService;
using WIDESEA_Model.Models;
@@ -19,6 +22,18 @@
        public OutboundOrderDetailController(IOutboundOrderDetailService service) : base(service)
        {
        }
        

        //[HttpPost, Route("GetOutboundDetailStockDataById"), AllowAnonymous, MethodParamsValidate]
        //public List<Dt_OutboundOrderDetail> GetOutboundDetailStockDataById (int id)
        //{
        //    return Service.GetOutboundStockDataById(id);
        //}


        public override ActionResult GetPageData(PageDataOptions options)
        {
           return  Json( Service.GetPageData(options));
        }

    }
}