1

yangpeixing

2026-04-01 f1bf3ef09713182d434e22dfd8623ea73e02d6d3

 WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -20,20 +20,30 @@
using Microsoft.AspNetCore.SignalR;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Database;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using Org.BouncyCastle.Asn1.Tsp;
using Spire.Pdf;
using SqlSugar;
using System;
using System;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Drawing.Printing;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;
using System.Threading.Tasks;
using WIDESEA_BasicRepository;
using WIDESEA_Common;
using WIDESEA_Common.Log;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
@@ -43,6 +53,7 @@
using WIDESEA_Core.Helper;
using WIDESEA_Core.TaskEnum;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.ERP;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Stock;
using WIDESEA_DTO.Task;
@@ -50,6 +61,7 @@
using WIDESEA_IBasicService;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_InboundRepository;
using WIDESEA_IOutboundRepository;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
@@ -59,13 +71,17 @@
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;
using WIDESEA_Model.Models.Inbound;
using WIDESEA_OutboundRepository;
using WIDESEA_StockRepository;
using WIDESEA_TaskInfoRepository;
using static WIDESEA_Common.Authentication;
using static WIDESEA_Common.HouseBackboundPassBack;
using static WIDESEA_Common.HouseInboundPassBack;
using static WIDESEA_Common.HouseInboundPassBack.data.data1;
using static WIDESEA_Common.HouseoutboundPassBack;
using static WIDESEA_Common.InventoryAllocate;
using static WIDESEA_Common.NewHouseInboundPassBack;
using static WIDESEA_Common.NewHouseInboundPassBack.Parame.Syncretism;
using static WIDESEA_ITaskInfoService.ITaskService;
using Parameter = WIDESEA_Common.Parameter;
using WIDESEA_DTO.ERP;
@@ -81,6 +97,7 @@
using System;
using WIDESEA_Common.Log;
using static WIDESEA_Common.HouseInboundPassBack.data.data1;
using System.Diagnostics;

namespace WIDESEA_TaskInfoService
{
@@ -600,7 +617,7 @@
                                return WebResponseContent.Instance.Error($"未找到对应的入库单明细");
                            }

                            // 更新入库单明细状态
                            // 更新入库单明细状态  
                            foreach (var inboundOrderDetail in inboundOrderDetails)
                            {
                                // 检查该明细是否已全部入库
@@ -720,6 +737,7 @@
                                }
                                if (inboundOrder.OrderStatus == InboundStatusEnum.入库完成.ObjToInt() && inboundOrder.OrderType == 0 && inboundOrder.System.Equals("SMOM"))
                                {

                                    List<Dt_StockInfo> StockInfos = _stockRepository.StockInfoRepository.Db
                                        .Queryable<Dt_StockInfo>()
                                        .Includes(x => x.Details, d => d.StockDetails)
@@ -872,7 +890,79 @@
                                        }
                                    }
                                }
                                else if (inboundOrder.OrderStatus == InboundStatusEnum.入库完成.ObjToInt() && inboundOrder.OrderType == 5 && inboundOrder.System.Equals("SMOM"))
                                {

                                    List<Dt_StockInfo> StockInfos = _stockRepository.StockInfoRepository.Db
                                         .Queryable<Dt_StockInfo>()
                                         .Includes(x => x.Details, d => d.StockDetails)
                                         .Where(x => x.WarehouseId == task.WarehouseId &&
                                                     x.Details.Any(v => v.OrderNo == inboundOrder.OrderNo))
                                         .ToList();

                                    Dt_InboundOrder? dt_InboundOrder = _inboundService.InbounOrderService.Db.Queryable<Dt_InboundOrder>().Where(x => x.OrderNo == inboundOrder.OrderNo).Includes(x => x.Details).First();
                                    if (StockInfos.Count == 0) throw new Exception("未找到库存信息");

                                    var houseSyncretism = new NewHouseInboundPassBack
                                    {
                                        ApiType = "InventoryMoveController",
                                        Method = "AsrsUnPickingDatas",
                                        Parameters = new List<NewHouseInboundPassBack.Parame>
                                        {
                                            new NewHouseInboundPassBack.Parame
                                            {

                                                Value =  new Parame.Syncretism
                                                    {
                                                        OrderNo = inboundOrder.OrderNo,
                                                        Details =   StockInfos.SelectMany(stockInfo =>

                                                    stockInfo.Details.Select(g =>
                                                    {
                                                       //var InboundOrderde1=dt_InboundOrder.Details.FirstOrDefault;

                                                       return new Parame.Syncretism.details
                                                       {
                                                        MoveType = 0,
                                                        WareHouseCode = warehouse.WarehouseCode,
                                                        ItemCode = g.MaterielCode,
                                                        MoveNumber = g.StockQuantity,
                                                        LotNo = g.BatchNo,
                                                        WipBatch = g.BatchNo,
                                                        Lpn = g.StockDetails.FirstOrDefault().LPNNO,
                                                        LocationName = g.StockDetails.FirstOrDefault().OrinalLocation,
                                                        TargetLocName = stockInfo.LocationCode, // 添加null检查
                                                        TargetLpn = stockInfo.PalletCode, // 添加null检查
                                                       };


                                                    })).ToList()

                                                    }

                                            }
                                        }
                                    };

                                    var authResult = AuthenticateWithWMS();
                                    if (authResult.IsSuccess)
                                    {
                                        houseSyncretism.Context = new Dictionary<string, string>
                                            {
                                                { "Ticket", authResult.Ticket },
                                                { "InvOrgId", authResult.InvOrgId }

                                            };

                                        var response = HttpHelper.Post<MomRequestContent>(ReceiveWMSTaskin, houseSyncretism, "立库入库数量回传WMS");
                                        if (!response.Success)
                                        {
                                            throw new Exception($"操作失败: {response.Message ?? "未提供错误信息"}");
                                        }

                                    }

                                }
                                _unitOfWorkManage.CommitTran();
                                return WebResponseContent.Instance.OK();
                            }
@@ -1341,7 +1431,7 @@

            _recordService.StockQuantityChangeRecordService.AddStockChangeRecord(
                stockInfo, stockInfo.Details,
                stockInfo.Details.Sum(x => x.StockQuantity),
                0,
                stockInfo.Details.Sum(x => x.StockQuantity),
                StockChangeType.Inbound, task.TaskNum);
        }
@@ -1686,11 +1776,14 @@
                                       x.LocationName == stockInfo.LocationCode &&
                                       x.LPNNo == stockInfo.PalletCode)
                                .ToList();

                            List<Dt_NewOutboundOrderDetail> outboundOrderDetails1 = _outboundService.NewOutboundOrderDetailService.Db.Queryable<Dt_NewOutboundOrderDetail>()
                                .Where(x => x.OrderId == outboundOrder.Id)                                 
                                .ToList();
                            if ((outboundOrderDetails == null && outboundOrderDetails1 == null) || (outboundOrderDetails.Count == 0  && outboundOrderDetails1.Count == 0))
                            List<Dt_NewOutboundOrderDetail> outboundOrderDetails1 = new List<Dt_NewOutboundOrderDetail>();
                            if (outboundOrderDetails == null || outboundOrderDetails.Count == 0)
                            {
                                outboundOrderDetails1 = _outboundService.NewOutboundOrderDetailService.Db.Queryable<Dt_NewOutboundOrderDetail>()
                                       .Where(x => x.OrderId == outboundOrder.Id)
                                       .ToList();
                            }
                            if ((outboundOrderDetails == null && outboundOrderDetails1 == null) || (outboundOrderDetails.Count == 0 && outboundOrderDetails1.Count == 0))
                            {
                                throw new Exception($"未找到托盘 {stockInfo.PalletCode} 在货位 {stockInfo.LocationCode} 上的出库单明细");
                            }
@@ -1698,6 +1791,7 @@
                            var stockInfoDetails = stockInfo.Details.ToList();

                            int overCount = outboundOrder.Details.Count(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt());

                            if (outboundOrderDetails == null || outboundOrderDetails.Count == 0)
                            {
                                foreach (var stockDetail in stockInfoDetails)
@@ -1858,7 +1952,7 @@
                                        }

                                        // 调拨出库
                                        if (outboundOrder.OrderType == 2)
                                        if (outboundOrder.OrderType == 4)
                                        {
                                            var allocate = new InventoryAllocate
                                            {
@@ -2090,7 +2184,7 @@
                                        }

                                        // 调拨出库
                                        if (outboundOrder.OrderType == 2)
                                        if (outboundOrder.OrderType == 4)
                                        {
                                            var allocate = new InventoryAllocate
                                            {
@@ -2177,14 +2271,18 @@
                        if (inboundOrder == null) return WebResponseContent.Instance.Error("未找到出库单信息");

                        List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();
                        foreach(var detail in stockInfo.Details)
                        foreach (var detail in stockInfo.Details)
                        {
                            Dt_OutboundOrderDetail outboundOrderDetail = _outboundService.OutboundOrderService.Db.Queryable<Dt_OutboundOrderDetail>()
                           .Where(x => x.OrderId == inboundOrder.Id && x.BatchNo == detail.BatchNo).First();
                            outboundOrderDetails.Add(outboundOrderDetail);
                            if (outboundOrderDetail != null)
                            {
                                outboundOrderDetails.Add(outboundOrderDetail);
                            }
                         
                        }

                        for(var i = 0; i<outboundOrderDetails.Count; i++)
                        for (var i = 0; i < outboundOrderDetails.Count; i++)
                        {
                            if (outboundOrderDetails[i].LocationName != null && outboundOrderDetails[i].LocationName != "")
                            {
@@ -2297,9 +2395,9 @@

                // 更新库存状态 回库单

                 AddRetrueOrder(stockInfo, inboundOrder);
     
                   
                AddRetrueOrder(stockInfo, inboundOrder);


                // 区分单据数据来源更新货位状态
                if (inboundOrder.System == null)
                {
@@ -2390,11 +2488,12 @@
                // 添加状态变更记录
                AddStatusChangeRecord(task, stockInfo, locationInfo);

               
                // 根据订单类型处理不同逻辑

                var outboundOrder = _outboundService.OutboundOrderService.Db.Queryable<Dt_OutboundOrder>()
                    .Where(x => x.OrderNo == inboundOrder.OrderNo).First();
                foreach(var outboundOrderDetail in outboundOrderDetails)
                foreach (var outboundOrderDetail in outboundOrderDetails)
                {
                    var outDetail = _outboundService.OutboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                   .Where(x => x.OrderId == outboundOrder.Id && x.BatchNo == outboundOrderDetail.BatchNo).First();
@@ -2465,12 +2564,11 @@
        private void DWANDYSUpdateOutboundOrderDetails(Dt_StockInfo stockInfo, Dt_OutboundOrder inboundOrder, ref List<Dt_OutboundOrderDetail> inboundOrderDetails)
        {
            List<Dt_OutboundOrderDetail> newOutboundOrderDetails = inboundOrderDetails;
            int overCount = inboundOrder.Details.Count(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt());
            int CompeletedNum = inboundOrder.Details.Where(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt()).Count();
            foreach (var newOutboundOrderDetail in newOutboundOrderDetails)
            {
                string BatchNo = newOutboundOrderDetail.BatchNo;
                //inboundOrderDetail = inboundOrder.Details.FirstOrDefault(x => x.BatchNo == stockInfo.Details.FirstOrDefault()?.BatchNo&&x.LPNNo==stockInfo.PalletCode);

                foreach (var item in stockInfo.Details)
                {
                    if (newOutboundOrderDetail == null) continue;
@@ -2484,21 +2582,22 @@
                        if (newOutboundOrderDetail.OverOutQuantity == newOutboundOrderDetail.OrderQuantity)
                        {
                            newOutboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
                            overCount++;
                            CompeletedNum++;
                        }
                        else if (newOutboundOrderDetail.OrderDetailStatus == OrderDetailStatusEnum.New.ObjToInt())
                        {
                            newOutboundOrderDetail.OrderDetailStatus = OutboundStatusEnum.出库中.ObjToInt();
                   
                            inboundOrder.OrderStatus = OutboundStatusEnum.出库中.ObjToInt();
                        }
                    }
                }
                if (inboundOrder.Details.Count() == overCount)
                if (inboundOrder.Details.Count == CompeletedNum)
                {
                    inboundOrder.OrderStatus = OutboundStatusEnum.出库完成.ObjToInt();
                }
            }
  

        }

        private void DeleteAndMoveIntoHtStockStatus(Dt_StockInfo stockInfo)
@@ -2529,6 +2628,12 @@
                StockChangeType.Outbound.ObjToInt(),
                stockInfo.Details.FirstOrDefault()?.OrderNo ?? "",
                task.TaskNum);

            _recordService.StockQuantityChangeRecordService.NEWAddStockChangeRecord(
                stockInfo, stockInfo.Details,
                stockInfo.Details.Sum(x => x.StockQuantity),
                stockInfo.Details.Sum(x => x.OutboundQuantity),
                StockChangeType.Outbound, task.TaskNum);
        }

        private void ProcessNormalOutbound(Dt_Task task, Dt_StockInfo stockInfo,
@@ -2954,9 +3059,9 @@
                            }
                        }
                        // 只减去单据明细中的数量
                        matchedStockDetail.OutboundQuantity = 0;
                        matchedStockDetail.StockQuantity = outDetail.OrderQuantity;
                        matchedStockDetail.OrderNo = returnOrder.OrderNo;
                        //matchedStockDetail.OutboundQuantity = 0;
                        //matchedStockDetail.StockQuantity = outDetail.OrderQuantity;
                        //matchedStockDetail.OrderNo = returnOrder.OrderNo;
                        // 更新匹配的明细
                        _stockService.StockInfoDetailService.Repository.UpdateData(matchedStockDetail);
                    }
@@ -2971,163 +3076,165 @@
                else
                {
                    var groupedDetails = outboundOrderDetails
             .GroupBy(d => new { d.MaterielCode, d.BatchNo })
             .ToList();
                        .GroupBy(d => new { d.MaterielCode, d.BatchNo })
                        .ToList();
                    List<Dt_StockInfoDetail> processedStockDetails = new List<Dt_StockInfoDetail>();
                    List<Dt_ReturnOrder> returnOrders = new List<Dt_ReturnOrder>();

                    decimal totalOutboundQuantity = outboundOrderDetails.Sum(x => x.OrderQuantity);
                    decimal totalStockQuantity = stockInfoDetails.Sum(x => x.StockQuantity);

                    foreach (var groupeDetail in groupedDetails)
                    foreach (var detail in stockInfo.Details)
                    {
                        var outboundDetail = groupeDetail.First();
                        decimal totalOrderQuantity = groupeDetail.Sum(x => x.OrderQuantity);
                        var matchedStockDetail = stockInfoDetails.FirstOrDefault(x => x.MaterielCode == outboundDetail.MaterielCode && x.BatchNo == outboundDetail.BatchNo);
                        if (matchedStockDetail == null)
                        foreach (var groupeDetail in groupedDetails)
                        {
                            matchedStockDetail = stockInfoDetails.FirstOrDefault(x => x.MaterielCode == outboundDetail.MaterielCode);

                            if (matchedStockDetail == null)
                            var outboundDetail = groupeDetail.First();
                            if (outboundDetail.MaterielCode == detail.MaterielCode)
                            {
                                throw new Exception($"未找到匹配的库存明细信息，物料:{outboundDetail.MaterielCode}, 批次:{outboundDetail.BatchNo}");
                                decimal totalOrderQuantity = groupeDetail.Sum(x => x.OrderQuantity);
                                var matchedStockDetail = stockInfoDetails.FirstOrDefault(x => x.MaterielCode == outboundDetail.MaterielCode && x.BatchNo == outboundDetail.BatchNo);
                                if (matchedStockDetail == null)
                                {
                                    matchedStockDetail = stockInfoDetails.FirstOrDefault(x => x.MaterielCode == outboundDetail.MaterielCode);

                                    if (matchedStockDetail == null)
                                    {
                                        throw new Exception($"未找到匹配的库存明细信息，物料:{outboundDetail.MaterielCode}, 批次:{outboundDetail.BatchNo}");
                                    }
                                }
                                // 计算当前批次的剩余数量
                                decimal remainingQuantity = matchedStockDetail.StockQuantity - totalOrderQuantity;

                                if (remainingQuantity > 0)
                                {
                                    Dt_ReturnOrder returnOrder = new Dt_ReturnOrder
                                    {
                                        MaterielCode = matchedStockDetail.MaterielCode,
                                        MaterielName = matchedStockDetail.MaterielName,
                                        BatchNo = matchedStockDetail.BatchNo,
                                        OrderQuantity = remainingQuantity,
                                        ReceiptQuantity = remainingQuantity,
                                        OrderStatus = InOrderStatusEnum.未开始.ObjToInt(),
                                        LinId = matchedStockDetail.LinId,
                                        LPNNo = stockInfo.PalletCode,
                                        Creater = "LK",
                                        CreateDate = DateTime.Now,
                                        OrderType = OrderTypeEnum.余料回库单.ObjToInt(),
                                        System = "WMS",
                                        Remark = "多批次返库"  // 添加备注标识
                                    };

                                    if (outboundOrder.System == "SMOM" && stockInfo.LocationCode != null)
                                    {
                                        returnOrder.LocationCode = stockInfo.LocationCode;
                                    }

                                    // 添加返库单
                                    returnOrders.Add(returnOrder);

                                }
                                if (remainingQuantity < 0 && matchedStockDetail.StockQuantity < matchedStockDetail.OutboundQuantity)
                                {
                                    throw new Exception($"出库数量 {outboundDetail.OrderQuantity} 大于库存数量 {matchedStockDetail.StockQuantity}");
                                }
                                processedStockDetails.Add(matchedStockDetail);


                                // 处理其他批次的库存明细（全部返库）
                                var otherBatchDetails = stockInfoDetails
                                    .Where(x => !processedStockDetails.Contains(x) && x.StockQuantity > 0 && x.OutboundQuantity == 0)
                                    .ToList();

                                if (returnOrders == null || returnOrders.Count == 0)
                                {
                                    if (otherBatchDetails.Count > 0)
                                    {
                                        decimal totalOtherQuantity = otherBatchDetails.Sum(x => x.StockQuantity);

                                        // 为其他批次创建返库单（只创建一个，包含所有批次）
                                        var firstOtherDetail = otherBatchDetails.First();
                                        Dt_ReturnOrder otherReturnOrder = new Dt_ReturnOrder
                                        {
                                            MaterielCode = firstOtherDetail.MaterielCode,
                                            MaterielName = firstOtherDetail.MaterielName,
                                            BatchNo = firstOtherDetail.BatchNo,
                                            OrderQuantity = totalOtherQuantity,
                                            ReceiptQuantity = totalOtherQuantity,
                                            OrderStatus = InOrderStatusEnum.未开始.ObjToInt(),
                                            LinId = firstOtherDetail.LinId,
                                            LPNNo = stockInfo.PalletCode,
                                            Creater = "LK",
                                            CreateDate = DateTime.Now,
                                            OrderType = OrderTypeEnum.余料回库单.ObjToInt(),
                                            System = "WMS",
                                            Remark = $"多批次返库，共{otherBatchDetails.Count}个批次"
                                        };

                                        if (outboundOrder.System == "SMOM" && !string.IsNullOrEmpty(stockInfo.LocationCode))
                                        {
                                            otherReturnOrder.LocationCode = stockInfo.LocationCode;
                                        }
                                        returnOrders.Add(otherReturnOrder);
                                    }

                                }
                                else
                                {
                                    decimal totalOtherQuantity = otherBatchDetails.Sum(x => x.StockQuantity);
                                    foreach (var item in returnOrders)
                                    {
                                        item.OrderQuantity = totalOrderQuantity;
                                        item.ReceiptQuantity = totalOrderQuantity;
                                        item.Remark = $"多批次返库，共{otherBatchDetails.Count}个批次";
                                    }
                                }

                                // 批量更新已处理的库存明细
                                var updateDetails = processedStockDetails.Where(x => x.StockQuantity > 0).ToList();
                                if (updateDetails.Any())
                                {
                                    _stockService.StockInfoDetailService.Repository.UpdateData(updateDetails);
                                }

                                // 添加返库单
                                if (returnOrders.Any())
                                {
                                    _returnOrderRepository.AddData(returnOrders);
                                }

                                // 更新库存主表状态
                                decimal returnQuantity = totalStockQuantity - totalOutboundQuantity;
                                if (returnQuantity == 0 || stockInfo.Details.All(x => x.StockQuantity == x.OutboundQuantity))
                                {
                                    if (outboundOrder.System == "SMOM" && stockInfo.LocationCode != null)
                                    {
                                        Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == stockInfo.LocationCode);
                                        dt_LocationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                                        _basicRepository.LocationInfoRepository.UpdateData(dt_LocationInfo);
                                    }
                                    //全部出库，删除库存
                                    //DeleteAndMoveIntoHtStockStatus(stockInfo);
                                    //foreach (var item in stockInfo.Details)
                                    //{
                                    //    BaseDal.Db.Deleteable(item.StockDetails).ExecuteCommand();
                                    //}
                                }
                                else if (returnQuantity > 0)
                                {
                                    // 有余料返库
                                    stockInfo.LocationCode = "";
                                    stockInfo.StockStatus = StockStatusEmun.余料退库.ObjToInt();
                                    stockInfo.Remark = $"余料退库，共{returnOrders.Count}个返库单";
                                    _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                                }
                            }
                        }
                        // 计算当前批次的剩余数量
                        decimal remainingQuantity = matchedStockDetail.StockQuantity - totalOrderQuantity;

                        if (remainingQuantity > 0)
                        {
                            Dt_ReturnOrder returnOrder = new Dt_ReturnOrder
                            {
                                MaterielCode = matchedStockDetail.MaterielCode,
                                MaterielName = matchedStockDetail.MaterielName,
                                BatchNo = matchedStockDetail.BatchNo,
                                OrderQuantity = remainingQuantity,
                                ReceiptQuantity = remainingQuantity,
                                OrderStatus = InOrderStatusEnum.未开始.ObjToInt(),
                                LinId = matchedStockDetail.LinId,
                                LPNNo = stockInfo.PalletCode,
                                Creater = "LK",
                                CreateDate = DateTime.Now,
                                OrderType = OrderTypeEnum.余料回库单.ObjToInt(),
                                System = "WMS",
                                Remark = "多批次返库"  // 添加备注标识
                            };

                            if (outboundOrder.System == "SMOM" && stockInfo.LocationCode != null)
                            {
                                returnOrder.LocationCode = stockInfo.LocationCode;
                            }

                            // 添加返库单
                            returnOrders.Add(returnOrder);

                            // 更新当前批次明细：只保留出库数量，其余返库
                            matchedStockDetail.StockQuantity = remainingQuantity;
                            matchedStockDetail.OutboundQuantity = outboundDetail.OrderQuantity;
                            //matchedStockDetail.OrderNo = returnOrder.OrderNo;
                        }
                        else if (remainingQuantity == 0)
                        {
                            // 当前批次正好出完
                            matchedStockDetail.OutboundQuantity = matchedStockDetail.StockQuantity;
                            if (matchedStockDetail.StockQuantity == totalOrderQuantity)
                            {
                                _stockService.StockInfoDetailService.Repository.DeleteAndMoveIntoHty(
                                    matchedStockDetail, App.User.UserId == 0 ? OperateType.自动完成 : OperateType.人工完成);
                            }
                            else
                            {
                                matchedStockDetail.StockQuantity = 0;
                                _stockService.StockInfoDetailService.Repository.UpdateData(matchedStockDetail);
                            }
                        }
                        else
                        {
                            throw new Exception($"出库数量 {outboundDetail.OrderQuantity} 大于库存数量 {matchedStockDetail.StockQuantity}");
                        }
                        processedStockDetails.Add(matchedStockDetail);
                    }

                    // 处理其他批次的库存明细（全部返库）
                    var otherBatchDetails = stockInfoDetails
                        .Where(x => !processedStockDetails.Contains(x) && x.StockQuantity > 0)
                        .ToList();

                    if (otherBatchDetails.Count > 0)
                    {
                        decimal totalOtherQuantity = otherBatchDetails.Sum(x => x.StockQuantity);

                        // 为其他批次创建返库单（只创建一个，包含所有批次）
                        var firstOtherDetail = otherBatchDetails.First();
                        Dt_ReturnOrder otherReturnOrder = new Dt_ReturnOrder
                        {
                            MaterielCode = firstOtherDetail.MaterielCode,
                            MaterielName = firstOtherDetail.MaterielName,
                            BatchNo = firstOtherDetail.BatchNo,
                            OrderQuantity = totalOtherQuantity,
                            ReceiptQuantity = totalOtherQuantity,
                            OrderStatus = InOrderStatusEnum.未开始.ObjToInt(),
                            LinId = firstOtherDetail.LinId,
                            LPNNo = stockInfo.PalletCode,
                            Creater = "LK",
                            CreateDate = DateTime.Now,
                            OrderType = OrderTypeEnum.余料回库单.ObjToInt(),
                            System = "WMS",
                            Remark = $"多批次返库，共{otherBatchDetails.Count}个批次"
                        };

                        if (outboundOrder.System == "SMOM" && !string.IsNullOrEmpty(stockInfo.LocationCode))
                        {
                            otherReturnOrder.LocationCode = stockInfo.LocationCode;
                        }


                        returnOrders.Add(otherReturnOrder);
                    }

                    // 批量更新已处理的库存明细
                    var updateDetails = processedStockDetails.Where(x => x.StockQuantity > 0).ToList();
                    if (updateDetails.Any())
                    {
                        _stockService.StockInfoDetailService.Repository.UpdateData(updateDetails);
                    }

                    // 添加返库单
                    if (returnOrders.Any())
                    {
                        _returnOrderRepository.AddData(returnOrders);
                    }

                    // 更新库存主表状态
                    decimal returnQuantity = totalStockQuantity - totalOutboundQuantity;
                    if (returnQuantity == 0)
                    {
                        if (outboundOrder.System == "SMOM" && stockInfo.LocationCode != null)
                        {
                            Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == stockInfo.LocationCode);
                            dt_LocationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                            _basicRepository.LocationInfoRepository.UpdateData(dt_LocationInfo);
                        }
                        // 全部出库，删除库存
                        DeleteAndMoveIntoHtStockStatus(stockInfo);
                        foreach (var item in stockInfo.Details)
                        {
                            BaseDal.Db.Deleteable(item.StockDetails).ExecuteCommand();
                        }
                    }
                    else if (returnQuantity > 0)
                    {
                        // 有余料返库
                        stockInfo.LocationCode = "";
                        stockInfo.StockStatus = StockStatusEmun.余料退库.ObjToInt();
                        stockInfo.Remark = $"余料退库，共{returnOrders.Count}个返库单";
                        _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                    }

                    _unitOfWorkManage.CommitTran();
                }
                _unitOfWorkManage.CommitTran();
            }
            catch (Exception ex)
            {
@@ -3414,65 +3521,171 @@
            }
        }

        public virtual void PrintTestDirect(string fullPath)
        public void PrintTestDirect(string fullPath)
        {
            const int maxRetryCount = 3;
            const int retryDelayMs = 1000;

            if (!File.Exists(fullPath))
            {
                Console.WriteLine($"打印失败：文件不存在 {fullPath}");
                Console.WriteLine($"✗ 打印失败：文件不存在 {fullPath}");
                return;
            }

            // 获取配置的打印机名称
            string printerName = AppSettings.app("PrinterName");
            // 获取打印机名称配置
            string printerName = AppSettings.app("PrinterName")?.Trim();

            if (string.IsNullOrEmpty(printerName))
            {
                Console.WriteLine("✗ 打印失败：未配置打印机名称");
                return;
                // 如果没有配置，使用系统默认打印机
                printerName = GetDefaultPrinterUbuntu();
            }

            // 直接使用配置的打印机名称，不进行任何转换
            PrintUsingConfiguredPrinter(fullPath, printerName.Trim());
            PrintUsingUbuntuPrinter(fullPath, printerName);
        }
        /// <summary>
        /// 获取 Ubuntu 默认打印机
        /// </summary>
        private string GetDefaultPrinterUbuntu()
        {
            try
            {
                ProcessStartInfo psi = new ProcessStartInfo
                {
                    FileName = "lpstat",
                    Arguments = "-d",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    RedirectStandardOutput = true
                };

                using (Process process = new Process { StartInfo = psi })
                {
                    process.Start();
                    string output = process.StandardOutput.ReadToEnd();
                    process.WaitForExit();

                    // 解析默认打印机名称，例如: "system default destination: LenovoPrinter"
                    if (output.Contains(":"))
                    {
                        return output.Split(':')[1].Trim();
                    }
                    return "LenovoPrinter"; // 默认回退
                }
            }
            catch
            {
                return "LenovoPrinter";
            }
        }

        /// <summary>
        /// Ubuntu 打印实现
        /// </summary>
        private void PrintUsingUbuntuPrinter(string filePath, string printerName)
        {
            try
            {
                PrintWithLpr(filePath, printerName);

            }
            catch (Exception ex)
            {
                Console.WriteLine($"✗ 打印失败: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 使用 lpr 命令打印
        /// </summary>
        private void PrintWithLpr(string filePath, string printerName)
        {
            Console.WriteLine($"📄 正在打印到 {printerName}: {Path.GetFileName(filePath)}");

            // 使用 lp 命令，添加 -o raw 选项
            string command = $"lp -d {printerName} -o raw \"{filePath}\"";

            ExecuteShellCommand(command);
        }
        /// <summary>
        /// 执行 Shell 命令
        /// </summary>
        private void ExecuteShellCommand(string command)
        {
            ProcessStartInfo psi = new ProcessStartInfo
            {
                FileName = "/bin/bash",
                Arguments = $"-c \"{command.Replace("\"", "\\\"")}\"",
                UseShellExecute = false,
                CreateNoWindow = true,
                RedirectStandardOutput = true,
                RedirectStandardError = true
            };

            using (Process process = new Process { StartInfo = psi })
            {
                process.Start();
                string output = process.StandardOutput.ReadToEnd();
                string error = process.StandardError.ReadToEnd();
                process.WaitForExit();

                if (process.ExitCode == 0)
                {
                    Console.WriteLine($"✅ 打印任务提交成功");
                    if (!string.IsNullOrEmpty(output))
                        Console.WriteLine($"输出: {output}");
                }
                else
                {
                    throw new InvalidOperationException($"命令执行失败: {error}");
                }
            }
        }


        /// <summary>
        /// 只使用配置的打印机进行打印
        /// </summary>
        /// <summary>
        /// Ubuntu 打印方法 - 使用 lpr 命令
        /// </summary>
        private void PrintUsingConfiguredPrinter(string filePath, string printerName)
        {
            try
            {
                // 1. 首先验证打印机是否存在
                if (!IsPrinterInstalled(printerName))
                // 1. 检查打印机是否在线
                if (!IsPrinterAvailableUbuntu(printerName))
                {
                    Console.WriteLine($"✗ 打印机 '{printerName}' 未安装或不存在");
                    Console.WriteLine("\n系统已安装的打印机列表:");
                    foreach (string printer in System.Drawing.Printing.PrinterSettings.InstalledPrinters)
                    {
                        Console.WriteLine($"  - {printer}");
                    }
                    throw new InvalidOperationException($"打印机 '{printerName}' 未安装");
                    throw new InvalidOperationException($"打印机 '{printerName}' 不可用或未找到");
                }

                // 3. 使用 Spire.PDF 打印
                using (Spire.Pdf.PdfDocument pdf = new Spire.Pdf.PdfDocument())
                Console.WriteLine($"✓ 使用打印机: {printerName}");
                Console.WriteLine($"✓ 正在打印: {Path.GetFileName(filePath)}");

                // 2. 使用 lpr 命令打印
                ProcessStartInfo psi = new ProcessStartInfo
                {
                    // 加载文件
                    pdf.LoadFromFile(filePath);
                    FileName = "lpr",
                    Arguments = $"-P {printerName} \"{filePath}\"",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true
                };

                    // 设置打印机名称（只使用配置的名称）
                    pdf.PrintSettings.PrinterName = printerName;
                using (Process process = new Process { StartInfo = psi })
                {
                    process.Start();
                    string output = process.StandardOutput.ReadToEnd();
                    string error = process.StandardError.ReadToEnd();
                    process.WaitForExit();

                    Console.WriteLine($"✓ 使用配置的打印机: {printerName}");
                    Console.WriteLine($"✓ 正在打印: {Path.GetFileName(filePath)}");

                    // 直接打印
                    pdf.Print();
                    Console.WriteLine("✓ 打印任务已提交");
                    if (process.ExitCode == 0)
                    {
                        Console.WriteLine($"✓ 打印任务已提交到 {printerName}");
                    }
                    else
                    {
                        throw new InvalidOperationException($"打印失败: {error}");
                    }
                }
            }
            catch (Exception ex)
@@ -3483,155 +3696,29 @@
        }

        /// <summary>
        /// 从配置的友好名称获取实际的打印机名称
        /// Ubuntu 检查打印机可用性
        /// </summary>
        private string GetActualPrinterName(string displayName)
        {
            if (string.IsNullOrEmpty(displayName))
                return string.Empty;

            // 如果配置的是 "192.168.99.3 上的 Lenovo M7605D"
            if (displayName.Contains("192.168.99.3 上的 Lenovo M7605D"))
            {
                // 在系统中查找实际的打印机名称
                return FindActualPrinterForIP("192.168.99.3");
            }

            // 如果直接配置的是IP地址
            if (displayName.Contains("192.168.99.3"))
            {
                return FindActualPrinterForIP("192.168.99.3");
            }

            // 如果已经是实际的打印机名称，直接返回
            if (IsPrinterInstalled(displayName))
            {
                return displayName;
            }

            // 默认返回原名称
            return displayName;
        }

        /// <summary>
        /// 查找IP地址对应的实际打印机名称
        /// </summary>
        private string FindActualPrinterForIP(string ipAddress)
        private bool IsPrinterAvailableUbuntu(string printerName)
        {
            try
            {
                // 获取所有打印机
                var allPrinters = new List<string>();
                foreach (string printer in System.Drawing.Printing.PrinterSettings.InstalledPrinters)
                ProcessStartInfo psi = new ProcessStartInfo
                {
                    allPrinters.Add(printer);
                }

                Console.WriteLine($"查找IP地址 {ipAddress} 对应的打印机...");
                Console.WriteLine("系统打印机列表:");
                foreach (var printer in allPrinters)
                {
                    Console.WriteLine($"  - {printer}");
                }

                // 优先查找包含IP地址的打印机
                foreach (string printer in allPrinters)
                {
                    if (printer.Contains(ipAddress))
                    {
                        Console.WriteLine($"✓ 找到包含IP的打印机: {printer}");
                        return printer;
                    }
                }

                // 查找联想打印机
                foreach (string printer in allPrinters)
                {
                    if (printer.Contains("M7605D", StringComparison.OrdinalIgnoreCase))
                    {
                        Console.WriteLine($"✓ 找到联想打印机: {printer}");
                        return printer;
                    }
                }


                // 返回第一个可用的打印机
                if (allPrinters.Any())
                {
                    Console.WriteLine($"⚠️ 未找到精确匹配，使用第一个打印机: {allPrinters.First()}");
                    return allPrinters.First();
                }

                return string.Empty;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"查找打印机失败: {ex.Message}");
                return string.Empty;
            }
        }

        /// <summary>
        /// 检查打印机是否已安装
        /// </summary>
        private bool IsPrinterInstalled(string printerName)
        {
            try
            {
                foreach (string printer in System.Drawing.Printing.PrinterSettings.InstalledPrinters)
                {
                    if (printer.Equals(printerName, StringComparison.OrdinalIgnoreCase))
                    {
                        return true;
                    }
                }
                return false;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 使用原始打印命令
        /// </summary>
        private void PrintUsingRawCommand(string filePath, string printerName)
        {
            try
            {
                var processStartInfo = new System.Diagnostics.ProcessStartInfo
                {
                    FileName = filePath,
                    Verb = "print",  // 使用"print"动词
                    UseShellExecute = true,  // 关键：启用Shell执行
                    FileName = "lpstat",
                    Arguments = $"-p {printerName}",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden
                    RedirectStandardOutput = true
                };

                // 设置打印机（可选，系统通常会使用默认打印机）
                // processStartInfo.Arguments = $"/t \"{filePath}\" \"{printerName}\"";

                System.Diagnostics.Process.Start(processStartInfo);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"打印失败: {ex.Message}");
                // 可以尝试其他方法
                //TryAlternativePrintMethod(filePath, printerName);
            }
        }


        /// <summary>
        /// 检查文件是否可访问
        /// </summary>
        private bool IsFileAccessible(string filePath)
        {
            try
            {
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                using (Process process = new Process { StartInfo = psi })
                {
                    return fs.Length > 0;
                    process.Start();
                    string output = process.StandardOutput.ReadToEnd();
                    process.WaitForExit();

                    return output.Contains($"{printerName} is idle") ||
                           output.Contains($"{printerName} is ready");
                }
            }
            catch
@@ -3639,25 +3726,6 @@
                return false;
            }
        }

        /// <summary>
        /// 尝试强制垃圾回收，释放可能存在的文件句柄
        /// </summary>
        private void TryForceGarbageCollection()
        {
            try
            {
                GC.Collect();
                GC.WaitForPendingFinalizers();
                Console.WriteLine("已执行垃圾回收");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"垃圾回收失败: {ex.Message}");
            }
        }


        /// <summary>
        /// 盘点出库完成
        /// </summary>