using System;
using System.Collections.Generic;
using SqlSugar;
using System.Linq;
using System.Linq.Expressions;
using Model.InterFaceModel;
using Model.ModelDto;
using SqlSugar.Extensions;
using WMS.Entity.BllSoEntity;
using WMS.Entity.Context;
using WMS.Entity.DataEntity;
using WMS.Entity.SysEntity;
using WMS.IBLL.IPdaServer;
using Model.ModelVm;
using Model.ModelVm.PdaVm;
using Newtonsoft.Json;
using Utility.Tools;
using WMS.BLL.LogServer;
using WMS.DAL;
using WMS.Entity.LogEntity;
using WMS.Entity.BllQualityEntity;
using WMS.Entity.BllAsnEntity;
using System.Threading.Tasks;
using Utility;

namespace WMS.BLL.BllPdaServer
{
    public class PdaSoServer : IPdaSoServer
    {
        private static readonly SqlSugarScope Db = DataContext.Db;

        #region JC34

        /// <summary>
        /// 拼托出库pda拣货-标签
        /// </summary>
        /// <param name="soNo"></param>
        /// <param name="soDetailId"></param>
        /// <param name="palletNo"></param>
        /// <param name="boxNo"></param>
        /// <param name="palletNoNew"></param>
        /// <param name="userId"></param>
        public async Task SoSetPinPick34(string soNo, string soDetailId, string palletNo, string boxNo , string palletNoNew, int userId)
        {
            Db.BeginTran();
            try
            {
                var nowDate = DateTime.Now;//当前时间
                #region 判断

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw Oops.Bah("出库单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(soDetailId))
                {
                    throw Oops.Bah("出库物料-批次不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘码不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNoNew))
                {
                    throw Oops.Bah("新托盘码不能为空");
                }
                if (palletNo == palletNoNew)//原托盘与新托盘一致
                {
                    if (!string.IsNullOrEmpty(boxNo))
                    {
                        throw Oops.Bah("原托盘与新托盘一致，请选择整托出库");
                    }
                }

                //出库单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                    .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw Oops.Bah("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                    m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                    m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                if (allot == null)
                {
                    throw Oops.Bah("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;

                //库存明细
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存信息！");
                }

                #endregion

                #region 拼托信息
                var sdId = 0;
                bool isNew = false;
                
                var pinStockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.SkuNo == stockDetail.SkuNo && m.LotNo == stockDetail.LotNo);
                 
                if (pinStockDetail != null)
                {
                    if (palletNo != palletNoNew)//非整托拣货
                    {
                        var pinStockDetails = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Id!= pinStockDetail.Id).ToList();
                        if (pinStockDetails.Count(m=>m.SONo != notice.SONo) > 0)
                        {
                            throw Oops.Bah("拼托托盘上只能放同一个出库单下的物料！");
                        }
                    }
                    
                    sdId = pinStockDetail.Id;
                }
                else
                {
                    isNew = true;

                    var newPalletInfo = await Db.Queryable<SysPallets>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
                    if (newPalletInfo == null)
                    {
                        throw Oops.Bah("新托盘信息不存在或已被使用！");
                    }
                    //修改新托盘状态
                    newPalletInfo.Status = "1";
                    await Db.Updateable(newPalletInfo).ExecuteCommandAsync();
                }
                
                var sd = new DataStockDetail();
                if (isNew)
                {
                    sd.LotNo = stockDetail.LotNo;
                    sd.LotText = stockDetail.LotText;
                    sd.SupplierLot = stockDetail.SupplierLot;
                    sd.SkuNo = stockDetail.SkuNo;
                    sd.SkuName = stockDetail.SkuName;
                    sd.Standard = stockDetail.Standard;

                    sd.FrozenQty = 0;
                    sd.InspectQty = 0;
                    sd.ASNNo = "";
                    sd.ASNDetailNo = null;
                    sd.SONo = soNo;//出库单号
                    sd.WareHouseNo = "";
                    sd.RoadwayNo = "";
                    sd.AreaNo = "";
                    sd.LocatNo = "";
                    sd.PalletNo = palletNoNew;
                    sd.PalletNo2 = "";
                    sd.PalletNo3 = "";

                    sd.CompleteTime = nowDate;
                    sd.ProductionTime = stockDetail.ProductionTime;
                    sd.ExpirationTime = stockDetail.ExpirationTime;
                    sd.Status = "2";//状态，已分配
                    sd.InspectMark = stockDetail.InspectMark;
                    sd.InspectStatus = stockDetail.InspectStatus;
                    sd.BitPalletMark = "0";
                    sd.PackagNo = noticeDetail.PackagNo;
                    sd.IsBale = stockDetail.IsBale;
                    sd.IsBelt = stockDetail.IsBelt;
                    sd.Demo = stockDetail.Demo;
                    sd.OwnerName = stockDetail.OwnerName;
                    sd.OwnerNo = stockDetail.OwnerNo;
                    sd.SupplierName = stockDetail.SupplierName;
                    sd.SupplierNo = stockDetail.SupplierNo;

                    sd.IsDel = "0";
                    sd.CreateUser = userId;
                    sd.CreateTime = nowDate;
                    sd.UDF5 = "1";
                    //新增拼托库存明细信息
                    sdId = await Db.Insertable(sd).ExecuteReturnIdentityAsync();
                }
                #endregion

                decimal pickQty = 0;//拣货的数量
                if (string.IsNullOrWhiteSpace(boxNo))//整托拣货
                {
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo);//找到托盘上所有箱码
                    boxInfos = await boxInfo.ToListAsync();
                    if (boxInfo.Count() <= 0)
                    {
                        throw Oops.Bah("该托盘上没有可拣货的箱子");
                    }
                    var boxQty = await boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
                    if (boxQty[0] > needQty)
                    {
                        throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                    }

                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        if (comDetailList.Any(m => m.BoxNo == item.BoxNo))
                        {
                            throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
                        }
                        if (item.SkuNo != allot.SkuNo || item.LotNo != allot.LotNo)
                        {
                            throw Oops.Bah("当前托盘上有其他不同物料批次，拣货失败");
                        }
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        if (palletNo != palletNoNew)
                        {
                            item.StockDetailId = sdId;
                            item.BindNo = null;//托盘绑定号
                            item.PalletNo = palletNoNew;
                        }
                        item.Status = "5";//箱支状态，0：未组托  1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
                        //修改库存箱码明细
                        await Db.Updateable(item).ExecuteCommandAsync();

                        pickQty += item.Qty;
                    }
                    //添加拣货明细
                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    if (palletNo != palletNoNew)
                    {
                        var locateStr = stockDetail.LocatNo;
                        //删除原托盘库存明细
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();

                        //改变原托盘状态为：未使用
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();

                        //更改储位状态为空储位
                        var locate = Db.Queryable<SysStorageLocat>().First(m => m.IsDel == "0" && m.LocatNo == locateStr);
                        if (locate != null)
                        {
                            locate.Status = "0";
                            Db.Updateable(locate).ExecuteCommand();
                        }
                    }
                    else
                    {
                        stockDetail.SONo = soNo;
                        stockDetail.UDF5 = "1";
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }

                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = Db.Queryable<BllExportNoticeDetail>().Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();
                }
                else
                {
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
                    if (await boxInfo.CountAsync() == 0)
                    {
                        throw Oops.Bah("未查询到该箱码的信息");
                    }
                    boxInfos = boxInfo.ToList();
                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
                    
                    //整箱拣货
                    
                    if (boxInfo.Any(m => m.PalletNo != palletNo))
                    {
                        throw Oops.Bah("该托盘与箱码没有绑定关系");
                    }
                    var boxQty = await boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
                    if (boxQty[0] > needQty)
                    {
                        throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                    }
                    
                    foreach (var item in boxInfos)
                    {
                        if (comDetailList.Any(m => m.BoxNo == item.BoxNo))
                        {
                            throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
                        }
                    }
                    

                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        //修改库存箱码明细
                        if (palletNo != palletNoNew)
                        {
                            item.StockDetailId = sdId;
                            item.BindNo = null;//托盘绑定号
                            item.PalletNo = palletNoNew;
                        }
                        
                        item.Status = "5";//箱支状态，0：未组托  1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
                        await Db.Updateable(item).ExecuteCommandAsync();

                        pickQty += item.Qty;
                        
                    }
                    
                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.Qty -= pickQty;
                    stockDetail.LockQty -= pickQty;
                    stockDetail.UDF5 = "1";
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }

                    if (stockDetail.Qty <= 0)
                    {
                        var locateStr = stockDetail.LocatNo;
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();

                        //改变托盘状态
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();

                        //更改储位状态为空储位
                        var locate = Db.Queryable<SysStorageLocat>().First(m => m.IsDel == "0" && m.LocatNo == locateStr);
                        if (locate != null)
                        {
                            locate.Status = "0";
                            Db.Updateable(locate).ExecuteCommand();
                        }
                    }
                    else
                    {
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                     
                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = await Db.Queryable<BllExportNoticeDetail>()
                        .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();
                }

                if (isNew)
                {
                    sd.Qty = pickQty;
                    sd.LockQty = pickQty;
                    await Db.Updateable(sd).ExecuteCommandAsync();
                }
                else
                {
                    if (palletNo != palletNoNew)
                    {
                        //修改拼托托盘库存明细
                        pinStockDetail.Qty += pickQty;
                        pinStockDetail.LockQty += pickQty;
                        await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
                    }
                }

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货拼托", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的原托盘码为：{palletNo}，新托盘码为：{palletNoNew}的拣货拼托操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        /// <summary>
        /// 拼托出库pda拣货-数量
        /// </summary>
        /// <param name="soNo"></param>
        /// <param name="soDetailId"></param>
        /// <param name="palletNo"></param>
        /// <param name="PickQty"></param>
        /// <param name="palletNoNew"></param>
        /// <param name="userId"></param>
        public async Task SoSetQtyPinPick34(string soNo, string soDetailId, string palletNo, string PickQty, string palletNoNew, int userId)
        {
            Db.BeginTran();
            try
            {
                var nowDate = DateTime.Now;//当前时间
                #region 判断

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw Oops.Bah("出库单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘码不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNoNew))
                {
                    throw Oops.Bah("新托盘码不能为空");
                }

                //出库单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                    .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw Oops.Bah("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                    m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                    m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                if (allot == null)
                {
                    throw Oops.Bah("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;
                if (int.Parse(PickQty) > needQty)
                {
                    throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
                }

                //库存明细
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存信息！");
                }
                if (palletNo == palletNoNew)//原托盘与新托盘一致
                {
                    if (int.Parse(PickQty) != stockDetail.Qty)
                    {
                        throw Oops.Bah("原托盘与新托盘一致，需要把托盘上所有数量拣货");
                    }
                }
                #endregion

                #region 拼托信息
                bool isNew = false;
                var pinStockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.SkuNo== stockDetail.SkuNo && m.LotNo == stockDetail.LotNo);
                if (pinStockDetail != null)
                {
                    if (palletNo != palletNoNew)//非整托拣货
                    {
                        var pinStockDetails = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Id != pinStockDetail.Id).ToList();
                        if (pinStockDetails.Count(m => m.SONo != notice.SONo) > 0)
                        {
                            throw Oops.Bah("拼托托盘上只能放同一个出库单下的物料！");
                        }
                    }
                }
                else
                {
                    isNew = true;

                    var newPalletInfo = await Db.Queryable<SysPallets>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
                    if (newPalletInfo == null)
                    {
                        throw Oops.Bah("新托盘信息不存在或已被使用！");
                    }
                    //修改新托盘状态
                    newPalletInfo.Status = "1";
                    await Db.Updateable(newPalletInfo).ExecuteCommandAsync();
                }

                if (isNew)
                {
                    var sd = new DataStockDetail();

                    sd.LotNo = stockDetail.LotNo;
                    sd.LotText = stockDetail.LotText;
                    sd.SupplierLot = stockDetail.SupplierLot;
                    sd.SkuNo = stockDetail.SkuNo;
                    sd.SkuName = stockDetail.SkuName;
                    sd.Standard = stockDetail.Standard;

                    sd.Qty = int.Parse(PickQty);
                    sd.LockQty = int.Parse(PickQty);

                    sd.FrozenQty = 0;
                    sd.InspectQty = 0;
                    sd.ASNNo = "";
                    sd.ASNDetailNo = null;
                    sd.SONo = soNo;//出库单号
                    sd.WareHouseNo = "";
                    sd.RoadwayNo = "";
                    sd.AreaNo = "";
                    sd.LocatNo = "";
                    sd.PalletNo = palletNoNew;
                    sd.PalletNo2 = "";
                    sd.PalletNo3 = "";
                    //PalletType = item.PalletType,
                    sd.CompleteTime = nowDate;
                    sd.ProductionTime = stockDetail.ProductionTime;
                    sd.ExpirationTime = stockDetail.ExpirationTime;
                    sd.Status = "2";//状态，已分配
                    sd.InspectMark = stockDetail.InspectMark;
                    sd.InspectStatus = stockDetail.InspectStatus;
                    sd.BitPalletMark = "0";
                    sd.PackagNo = noticeDetail.PackagNo;
                    sd.IsBale = stockDetail.IsBale;
                    sd.IsBelt = stockDetail.IsBelt;
                    sd.Demo = stockDetail.Demo;
                    sd.OwnerName = stockDetail.OwnerName;
                    sd.OwnerNo = stockDetail.OwnerNo;
                    sd.SupplierName = stockDetail.SupplierName;
                    sd.SupplierNo = stockDetail.SupplierNo;

                    sd.IsDel = "0";
                    sd.CreateUser = userId;
                    sd.CreateTime = nowDate;
                    sd.UDF5 = "1";

                    //新增拼托库存明细信息
                    await Db.Insertable(sd).ExecuteReturnIdentityAsync();
                }
                else
                {
                    if (palletNo != palletNoNew)
                    {
                        //修改拼托托盘库存明细
                        pinStockDetail.Qty += int.Parse(PickQty);
                        pinStockDetail.LockQty += int.Parse(PickQty);
                        pinStockDetail.UDF5 = "1";
                        await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        pinStockDetail.SONo = soNo;
                        pinStockDetail.UDF5 = "1";
                        await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
                    }
                }
                #endregion

                //获取当前托盘拣货明细
                var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

                //判读是否存在拣货明细
                int isComplete = 0;
                if (complete != null)
                {
                    isComplete = 1;
                }

                var comList = new List<BllCompleteDetail>();
                //判断是否存在拣货明细
                isComplete = 0;//所有无箱码或一级箱码拣货时，拣货明细应重新插入数据(体现多次拣货流程记录)
                if (isComplete == 0)
                {
                    //添加拣货明细
                    var completeDetail = new BllCompleteDetail()
                    {
                        SONo = soNo,
                        SODetailNo = int.Parse(soDetailId),
                        ExportAllotId = allot.Id,
                        StockId = allot.StockId,
                        BoxNo = "",
                        BoxNo2 = "",
                        BoxNo3 = "",

                        LotNo = allot.LotNo,
                        LotText = allot.LotText,
                        SupplierLot = allot.SupplierLot,
                        SkuNo = allot.SkuNo,
                        SkuName = allot.SkuName,
                        Standard = allot.Standard,
                        PalletNo = palletNo,
                        CompleteQty = int.Parse(PickQty),

                        CreateUser = userId,
                        CreateTime = Db.GetDate(),
                    };
                    comList.Add(completeDetail);

                    //添加拣货明细
                    await Db.Insertable(comList).ExecuteCommandAsync();
                }
                else if (isComplete == 1)
                {
                    complete.CompleteQty += int.Parse(PickQty);
                    complete.UpdateUser = userId;
                    complete.UpdateTime = Db.GetDate();

                    await Db.Updateable(complete).ExecuteCommandAsync();
                }

                //修改出库分配信息
                allot.CompleteQty += int.Parse(PickQty);
                allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                allot.UpdateTime = DateTime.Now;
                await Db.Updateable(allot).ExecuteCommandAsync();

                int isDel = 0;
                var locateStr = stockDetail.LocatNo;
                if (palletNo != palletNoNew)
                {
                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.Qty -= int.Parse(PickQty);
                    stockDetail.LockQty -= int.Parse(PickQty);
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }
                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        isDel = 1;
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                }
                else
                {
                    isDel = 1;
                }
                //判断托盘上物料是否拣货完毕
                if (isDel == 0)
                {
                    //改变托盘状态为：未使用
                    var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                    if (pallet == null)
                    {
                        throw Oops.Bah("未在托盘表中查询到托盘信息");
                    }

                    pallet.Status = "0";
                    await Db.Updateable(pallet).ExecuteCommandAsync();

                    //更改储位状态为空储位
                    var locate = Db.Queryable<SysStorageLocat>().First(m=>m.IsDel == "0" && m.LocatNo == locateStr);
                    if (locate!=null)
                    {
                        locate.Status = "0";
                        Db.Updateable(locate).ExecuteCommand();
                    }

                }

                //修改出库单明细拣货数量
                noticeDetail.CompleteQty += int.Parse(PickQty);
                await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                var num = await Db.Queryable<BllExportNoticeDetail>()
                    .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                if (num <= 0)
                {
                    notice.Status = "4"; //更改为执行完成
                }
                //修改出库单信息
                await Db.Updateable(notice).ExecuteCommandAsync();

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货拼托", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}，新托盘码为：{palletNoNew}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        #endregion

        //验证托盘是否存在并是否可出库
        public async Task<string> IsEnableOkPalletNo(string palletNo)
        {
            string sqlMsg = "";
            var models = await Db.Queryable<SysPallets>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo).ToListAsync();

            if (models.Count > 1)
            {
                throw Oops.Bah("-1:存在重复托盘号,请检查!");
            }
            if (models.Count > 0)
            {
                if (models[0].Status == "0")
                {
                    throw Oops.Bah("-1:托盘号状态为未使用!");
                }
            }
            else
            {
                throw Oops.Bah("-1:托盘号不存在!");
            }

            return sqlMsg;
        }

        //获取托盘中含有的执行中的单据
        public async Task<List<string>> GetRunSoNoticeList(string palletNo, string type)
        {
            if (string.IsNullOrWhiteSpace(palletNo))//判断托盘是否为空
            {
                throw Oops.Bah("托盘码为空，请输入托盘码");
            }
            var palletInfo = await Db.Queryable<DataStockDetail>().FirstAsync(w => w.IsDel == "0" && w.PalletNo == palletNo);
            //if (!string.IsNullOrEmpty(palletInfo.WareHouseNo) && type != "1")
            //{
            //    throw Oops.Bah("该托盘还未出库");
            //}
            if (type == "1")//平库出库获取单据
            {
                var allotList = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.Status == "1" && m.PalletNo == palletNo).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToListAsync();
                return allotList;
            }
            //获取状态为待拣货或者部分拣货的出库单
            var allotList2 = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.PalletNo == palletNo).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToListAsync();

            //var allotList = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToList();
            //获取出库单据不为待拣货 执行完毕 订单关闭 等待执行的单据
            //var export = Db.Queryable<BllExportNotice>().Where(a => a.IsDel == "0" && a.Status == "1" || a.Status == "2" || a.Status == "3").Select(a => a.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToList();

            return allotList2;
        }

        //获取托盘中含有的执行中的单据
        public async Task<List<string>> GetRunNoticeList(string type)
        {
            if (type == "1")//平库出库获取单据
            {
                var allotList = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && (m.Status == "1" || m.Status =="0")).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToListAsync();
                return allotList;
            }
            //获取状态为待拣货或者部分拣货的出库单
            var allotList2 = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && (m.Status == "2" || m.Status == "3")).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToListAsync();

            //var allotList = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToList();
            //获取出库单据不为待拣货 执行完毕 订单关闭 等待执行的单据
            //var export = Db.Queryable<BllExportNotice>().Where(a => a.IsDel == "0" && a.Status == "1" || a.Status == "2" || a.Status == "3").Select(a => a.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToList();

            return allotList2;
        }

        //获取出库托盘上的物料批次(根据托盘码)
        public async Task<List<DetailIdSkuLotNo>> GetSoSkuLotNoListByPallet(string palletNo, string soNo)
        {
            if (string.IsNullOrWhiteSpace(palletNo))//判断托盘是否为空
            {
                throw Oops.Bah("托盘码为空，请输入托盘码");
            }
            //获取状态为待拣货或者部分拣货的出库单
            var allotList = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.PalletNo == palletNo);
            //var allotList = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.SONo == soNo && m.Status != "4" && m.Status != "5");
            if (!string.IsNullOrWhiteSpace(soNo))
            {
                allotList = allotList.Where(m => m.SONo == soNo);
            }

            var list = await allotList.GroupBy(m => new { m.SODetailNo, m.PalletNo, m.SkuNo, m.SkuName, m.LotNo }).Select(m => new DetailIdSkuLotNo()
            {
                SoDetailId = m.SODetailNo,
                PalletNo = m.PalletNo,
                SkuNo = m.SkuNo,
                SkuName = m.SkuName,
                LotNo = m.LotNo,
            }).ToListAsync();

            return list;
        }

        //获取出库口、规格、待拣及已拣数量（根据出库单明细ID、托盘号）
        public async Task<OutPdaInfo> GetOutlets(string soDetailId, string palletNo)
        {
            var allotInfo = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo && (m.Status == "2" || m.Status == "3")).ToListAsync();
            if (allotInfo.Count == 0)
            {
                throw Oops.Bah($"{palletNo}托盘上未查询到分配信息，请核实");
            }
            if (allotInfo.Count > 1)
            {
                throw Oops.Bah($"{palletNo}托盘上存在多条相同的分配信息，请核实");
            }
            var data = allotInfo.First();
            var data2 = new OutPdaInfo()
            {
                OutModel = data.OutMode,
                Standard = data.Standard,
                PickQty = data.Qty,
                PickedQty = data.CompleteQty
            };
            return data2;
        }

        //获取出库单的计划数量和完成
        public async Task<OutPdaInfo> GetPlanAndFinishQty(string soDetailId)
        {
            var detail = await Db.Queryable<BllExportNoticeDetail>().FirstAsync(m => m.Id == int.Parse(soDetailId) && m.IsDel == "0");
            if (detail == null)
            {
                throw Oops.Bah("未查询到出库单的明细");
            }
            var data = new OutPdaInfo()
            {
                PlanQty = detail.Qty,
                FinishQty = detail.CompleteQty
            };
            return data;
        }

        //获取箱码信息（根据箱码在库存箱码明细中查询及拣货明细中拣货数量）
        public async Task<List<BoxInfo>> GetDataComBoxInfo(string soDetailId, string palletNo, string boxNo, string boxNo3)
        {
            if (string.IsNullOrWhiteSpace(palletNo))
            {
                throw Oops.Bah("托盘号不能为空");
            }
            Expression<Func<DataBoxInfo, bool>> item = Expressionable.Create<DataBoxInfo>()
                .And(it => it.PalletNo == palletNo)
                .AndIF(!string.IsNullOrWhiteSpace(boxNo), it => it.BoxNo == boxNo)
                .AndIF(!string.IsNullOrWhiteSpace(boxNo3), it => it.BoxNo3 == boxNo3)
                .And(m => m.IsDel == "0")
                .ToExpression();//注意 这一句 不能少
            var info = Db.Queryable<DataBoxInfo>().Where(item);
            if (info.Count() == 0)
            {
                throw Oops.Bah("未在库存中查询到信息");
            }

            var type = "0";//0：查箱码或支码不分组 1：查托盘分组 显示箱
            var list = new List<BoxInfo>();
            if (!string.IsNullOrWhiteSpace(boxNo3) || !string.IsNullOrWhiteSpace(boxNo))//判断支码是否为空
            {
                foreach (var demo in await info.ToListAsync())
                {
                    var t = new BoxInfo()
                    {
                        BoxNo = demo.BoxNo3,
                        Qty = demo.Qty,
                        //SkuNo = demo.SkuNo,
                        //SkuName = demo.SkuName,
                        //LotNo = demo.LotNo, 
                    };
                    list.Add(t);
                }

            }
            else if (!string.IsNullOrWhiteSpace(palletNo))
            {
                list = await info.GroupBy(m => new { m.BoxNo }).Select(it => new BoxInfo
                {
                    BoxNo = it.BoxNo,
                    Qty = SqlFunc.AggregateSum(it.Qty)
                }).ToListAsync();
                type = "1";
            }
            if (!string.IsNullOrWhiteSpace(soDetailId))
            {
                var allotInfos = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo && (m.Status == "2" || m.Status == "3")).ToListAsync();
                if (allotInfos.Count == 0)
                {
                    throw Oops.Bah($"{palletNo}托盘上未查询到分配信息，请核实");
                }
                if (allotInfos.Count > 1)
                {
                    throw Oops.Bah($"{palletNo}托盘上存在多条相同的分配信息，请核实");
                }
                var allotInfo = allotInfos.First();
                var comInfo = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allotInfo.Id).ToListAsync();
                if (comInfo.Count != 0)
                {
                    if (type == "0")
                    {
                        foreach (var demo in list)
                        {
                            //if (!string.IsNullOrWhiteSpace(boxNo3))
                            //{
                            //    var com = comInfo.FirstOrDefault(m => m.IsDel == "0" && m.BoxNo3 == demo.BoxNo);
                            //}
                            //else if (!string.IsNullOrWhiteSpace(boxNo))
                            //{
                            //    if (expr)
                            //    {

                            //    }

                            //}
                            var com = comInfo.FirstOrDefault(m => m.IsDel == "0" && m.BoxNo3 != null && m.BoxNo3 == demo.BoxNo);
                            if (com != null)
                            {
                                demo.PickedQty = com.CompleteQty;
                            }
                        }
                    }
                    if (type == "1")
                    {
                        var com = comInfo.Where(m => m.IsDel == "0").GroupBy(m => m.BoxNo).Select(it => new BoxInfo
                        {
                            BoxNo = it.Key,
                            PickedQty = it.Sum(a => a.CompleteQty)
                        }).ToList();
                        foreach (var demo in list)
                        {

                            var com2 = com.FirstOrDefault(m => m.BoxNo == demo.BoxNo);
                            if (com2 != null)
                            {
                                demo.PickedQty = com2.PickedQty;
                            }
                        }
                    }
                }

            }

            return list;
        }

        //获取库内无箱码的托盘分配信息
        public async Task<List<BoxInfo>> GetAllotPlnInfo(string soDetailId, string palletNo)
        {
            #region 判断

            //根据id及托盘获取出库单和托盘拣货信息
            if (string.IsNullOrWhiteSpace(palletNo))
            {
                throw Oops.Bah("托盘号不能为空");
            }
            //获取对应托盘下是否存在箱码信息
            var boxInfo = await Db.Queryable<DataBoxInfo>().FirstAsync(b => b.IsDel == "0" && b.PalletNo == palletNo);
            if (boxInfo != null)
            {
                throw Oops.Bah($"{palletNo}托盘上存在箱码信息，无法在数量拣货进行操作！");
            }

            BllExportAllot allot = null;
            if (!string.IsNullOrWhiteSpace(soDetailId))
            {
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>().FirstAsync(a => a.Id == int.Parse(soDetailId) && a.IsDel == "0");
                if (noticeDetail == null)
                {
                    throw Oops.Bah($"未查询到对应出库单明细信息，请核实！");
                }
                //出库单总单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(a => a.IsDel == "0" && a.SONo == noticeDetail.SONo);
                if (notice == null)
                {
                    throw Oops.Bah($"未查询到对应出库单总单信息，请核实！");
                }
                //分配信息
                allot = await Db.Queryable<BllExportAllot>().FirstAsync(a => a.IsDel == "0" && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.PalletNo == palletNo && (a.Status == "2" || a.Status == "3"));
                if (allot == null)
                {
                    throw Oops.Bah($"未查询到对应分配信息，请核实！");
                }
            }

            //库存明细
            var detail = await Db.Queryable<DataStockDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo);
            if (detail == null)
            {
                throw Oops.Bah($"未查询到库存明细信息，请核实！");
            }

            #endregion

            List<BoxInfo> pdaInfo = new List<BoxInfo>();

            BoxInfo info = new BoxInfo()
            {
                SkuNo = detail.SkuNo,
                BoxNo = detail.SkuNo,
                Qty = allot == null ? (int)(detail.Qty - detail.LockQty) : (int)allot.Qty,
                PickedQty = allot == null ? 0 : (int)allot.CompleteQty,
            };

            pdaInfo.Add(info);
            return pdaInfo;
        }

        //出库pda拣货
        public async Task SoSetPick(string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, int userId)
        {
            Db.BeginTran();
            try
            {
                #region 判断

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw Oops.Bah("出库单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(soDetailId))
                {
                    throw Oops.Bah("出库物料-批次不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘码不能为空");
                }
                if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
                {
                    throw Oops.Bah("追溯条码和拣货数量不能同时输入");
                }

                //出库单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                    .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw Oops.Bah("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                    m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                    m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                if (allot == null)
                {
                    throw Oops.Bah("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;

                //库存明细
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存信息！");
                }
                #endregion

                if (string.IsNullOrWhiteSpace(boxNo))//整托拣货
                {
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo);//找到托盘上所有箱码
                    boxInfos = await boxInfo.ToListAsync();
                    if (boxInfo.Count() <= 0)
                    {
                        throw Oops.Bah("该托盘上没有可拣货的箱子");
                    }
                    var boxQty = await boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
                    if (boxQty[0] > needQty)
                    {
                        throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                    }
                    decimal pickQty = 0;//拣货的数量
                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        if (comDetailList.Any(m => m.BoxNo3 == item.BoxNo3) && item.BoxNo3 != null)
                        {
                            throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                        }
                        if (item.SkuNo != allot.SkuNo || item.LotNo != allot.LotNo)
                        {
                            throw Oops.Bah("当前托盘上有其他不同物料批次，拣货失败");
                        }
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        //删除库存箱码明细
                        await Db.Deleteable(item).ExecuteCommandAsync();
                        pickQty += item.Qty;
                    }
                    //添加拣货明细
                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    await Db.Updateable(allot).ExecuteCommandAsync();
                    //删除库存明细
                    await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    //删除或修改库存
                    stock.Qty -= pickQty;
                    stock.LockQty -= pickQty;
                    if (stock.Qty <= 0)
                    {
                        await Db.Deleteable(stock).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stock).ExecuteCommandAsync();
                    }
                    //改变托盘状态为：未使用
                    var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
                    if (pallet == null)
                    {
                        throw Oops.Bah("未在托盘表中查询到托盘信息");
                    }
                    pallet.Status = "0";
                    await Db.Updateable(pallet).ExecuteCommandAsync();
                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = await Db.Queryable<BllExportNoticeDetail>()
                        .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                        //修改出库单信息
                        await Db.Updateable(notice).ExecuteCommandAsync();
                        if (notice.IsWave == "1")
                        {
                            var waveNum = await Db.Queryable<BllExportNotice>().CountAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
                            if (waveNum == 0)
                            {
                                var wave = await Db.Queryable<BllWaveMage>().FirstAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
                                if (wave != null)
                                {
                                    wave.Status = "4";
                                    wave.UpdateUser = userId;
                                    wave.UpdateTime = DateTime.Now;
                                    await Db.Updateable(wave).ExecuteCommandAsync();
                                }
                            }
                        }
                    }

                }
                else
                {
                    var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
                    if (await boxInfo.CountAsync() == 0)
                    {
                        throw Oops.Bah("未查询到该箱码及追溯码的信息");
                    }
                    boxInfos = await boxInfo.ToListAsync();

                    var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
                    if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
                    {
                        boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

                        if (boxInfos.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码及追溯码的信息");
                        }
                        if (boxInfos.Count() > 1)
                        {
                            throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
                        }

                        if (boxInfos.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = boxInfos.First().Qty;
                        if (boxQty > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于剩余待拣数量");
                        }

                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                            }
                        }

                        biaoShi = "1";
                    }
                    else if (!string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)//数量拣货
                    {
                        if (boxInfo.Count() > 1)
                        {
                            throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
                        }
                        decimal boxQty = boxInfo.First().Qty;
                        if (Convert.ToInt32(pickQty1) > boxQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }
                        if (Convert.ToInt32(pickQty1) > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于剩余待拣数量");
                        }

                        biaoShi = "2";
                    }
                    else //整箱拣货
                    {
                        if (boxInfo.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码的信息");
                        }
                        if (boxInfo.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = await boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
                        if (boxQty[0] > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                        }

                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
                            }
                        }
                    }
                    decimal pickQty = 0;//拣货的数量

                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = biaoShi == "2" ? decimal.Parse(pickQty1) : item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        if (biaoShi != "2")
                        {
                            //删除库存箱码明细
                            await Db.Deleteable(item).ExecuteCommandAsync();
                        }
                        else//数量拣货
                        {
                            if (decimal.Parse(pickQty1) == item.Qty)
                            {
                                //删除库存箱码明细
                                await Db.Deleteable(item).ExecuteCommandAsync();
                            }
                            else
                            {
                                item.Qty -= decimal.Parse(pickQty1);
                                item.BitBoxMark = "1";//零箱标识
                                await Db.Updateable(item).ExecuteCommandAsync();
                            }
                        }
                        pickQty += item.Qty;
                    }
                    //改变库内箱码是否零箱信息
                    if (biaoShi == "1")
                    {
                        var boxSurplusList = boxInfo.Where(m => m.BoxNo3 != boxNo3).ToList();
                        foreach (var item in boxSurplusList)
                        {
                            item.BitBoxMark = "1";
                            await Db.Updateable(item).ExecuteCommandAsync();
                        }
                    }

                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    if (allot.Status == "5")
                    {
                        //判断该托盘是否还存在物料 存在改为待回库 待回库完成后改为已完成
                    }
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.Qty -= pickQty;
                    stockDetail.LockQty -= pickQty;
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }

                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                    stock.Qty -= pickQty;
                    stock.LockQty -= pickQty;
                    if (stock.Qty <= 0)
                    {
                        await Db.Deleteable(stock).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stock).ExecuteCommandAsync();
                    }
                    var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
                    if (num2 <= 0)
                    {
                        //改变托盘状态
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }
                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = await Db.Queryable<BllExportNoticeDetail>()
                        .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                        //修改出库单信息
                        await Db.Updateable(notice).ExecuteCommandAsync();
                        if (notice.IsWave == "1")
                        {
                            var waveNum = await Db.Queryable<BllExportNotice>()
                                .CountAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
                            if (waveNum == 0)
                            {
                                var wave = await Db.Queryable<BllWaveMage>().FirstAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
                                if (wave != null)
                                {
                                    wave.Status = "4";
                                    wave.UpdateUser = userId;
                                    wave.UpdateTime = DateTime.Now;
                                    await Db.Updateable(wave).ExecuteCommandAsync();
                                }
                            }
                        }
                    }
                }
                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货出库", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (AppFriendlyException e)
            {
                Db.RollbackTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw new Exception(e.Message);
            }
        }

        //出库pda拣货
        public async Task SoSetQtyPick(string soNo, string soDetailId, string palletNo, string PickQty, int userId)
        {
            Db.BeginTran();
            try
            {
                #region 判断

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw Oops.Bah("出库单据不能为空");
                }
                //if (string.IsNullOrWhiteSpace(soDetailId))
                //{
                //    throw new Exception("出库物料-批次不能为空");
                //}
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘码不能为空");
                }

                //出库单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                    .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw Oops.Bah("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                    m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                    m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                if (allot == null)
                {
                    throw Oops.Bah("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;
                if (int.Parse(PickQty) > needQty)
                {
                    throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
                }

                //库存明细
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存信息！");
                }
                #endregion
                //获取当前托盘拣货明细
                var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

                //判读是否存在拣货明细
                int isComplete = 0;
                if (complete != null)
                {
                    isComplete = 1;
                }

                var comList = new List<BllCompleteDetail>();
                //判断是否存在拣货明细
                isComplete = 0;// 所有无箱码或一级箱码拣货时，拣货明细应重新插入数据(体现多次拣货流程记录)
                if (isComplete == 0)
                {
                    //添加拣货明细
                    var completeDetail = new BllCompleteDetail()
                    {
                        SONo = soNo,
                        SODetailNo = int.Parse(soDetailId),
                        ExportAllotId = allot.Id,
                        StockId = allot.StockId,
                        BoxNo = "",
                        BoxNo2 = "",
                        BoxNo3 = "",

                        LotNo = allot.LotNo,
                        LotText = allot.LotText,
                        SupplierLot = allot.SupplierLot,
                        SkuNo = allot.SkuNo,
                        SkuName = allot.SkuName,
                        Standard = allot.Standard,
                        PalletNo = palletNo,
                        CompleteQty = int.Parse(PickQty),

                        CreateUser = userId,
                        CreateTime = Db.GetDate(),
                    };
                    comList.Add(completeDetail);

                    //添加拣货明细
                    await Db.Insertable(comList).ExecuteCommandAsync();
                }
                else if (isComplete == 1)
                {
                    complete.CompleteQty += int.Parse(PickQty);
                    complete.UpdateUser = userId;
                    complete.UpdateTime = Db.GetDate();

                    await Db.Updateable(complete).ExecuteCommandAsync();
                }

                //修改出库分配信息
                allot.CompleteQty += int.Parse(PickQty);
                allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                allot.UpdateTime = DateTime.Now;
                await Db.Updateable(allot).ExecuteCommandAsync();

                int isDel = 0;

                //删除或修改库存明细
                stockDetail.BitPalletMark = "1";//修改为零托标识
                stockDetail.Qty -= int.Parse(PickQty);
                stockDetail.LockQty -= int.Parse(PickQty);
                if (stockDetail.Qty == stockDetail.LockQty)
                {
                    stockDetail.Status = "2";
                }
                else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                {
                    stockDetail.Status = "1";
                }
                else
                {
                    stockDetail.Status = "0";
                }
                if (stockDetail.Qty <= 0)
                {
                    await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                }
                else
                {
                    isDel = 1;
                    await Db.Updateable(stockDetail).ExecuteCommandAsync();
                }
                //删除或修改库存
                stock.Qty -= int.Parse(PickQty);
                stock.LockQty -= int.Parse(PickQty);
                if (stock.Qty <= 0)
                {
                    await Db.Deleteable(stock).ExecuteCommandAsync();
                }
                else
                {
                    await Db.Updateable(stock).ExecuteCommandAsync();
                }

                //改变托盘状态为：未使用
                var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                if (pallet == null)
                {
                    throw Oops.Bah("未在托盘表中查询到托盘信息");
                }

                //判断托盘上物料是否拣货完毕
                if (isDel == 0)
                {
                    pallet.Status = "0";
                    await Db.Updateable(pallet).ExecuteCommandAsync();
                }

                //修改出库单明细拣货数量
                noticeDetail.CompleteQty += int.Parse(PickQty);
                await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                var num = await Db.Queryable<BllExportNoticeDetail>()
                    .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                if (num <= 0)
                {
                    notice.Status = "4"; //更改为执行完成
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();
                    if (notice.IsWave == "1")
                    {
                        var waveNum = await Db.Queryable<BllExportNotice>().CountAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
                        if (waveNum <= 0)
                        {
                            var wave = await Db.Queryable<BllWaveMage>().FirstAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
                            if (wave != null)
                            {
                                wave.Status = "4";
                                wave.UpdateUser = userId;
                                wave.UpdateTime = DateTime.Now;
                                await Db.Updateable(wave).ExecuteCommandAsync();
                            }
                        }
                    }
                }


                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货出库", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        /// <summary>
        /// 下发空托出库
        /// </summary>
        /// <param name="model"> </param>
        /// <param name="userId"> </param>
        /// <param name="url"> </param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task<string> IssuePlnOutHouse(OutModePalletVm model, int userId, string url)
        {
            try
            {
                var outDtoList = new List<OutCommandDto>(); //出库数据的集合 
                //获取当前时间
                DateTime serverTime = Db.GetDate();
                //获取库存明细是否小于等于该垛数
                //string str = "select * from DataStockDetail where IsDel = '0' and SkuNo = '100099' and Status = '0' ";
                //var stockDetail = Db.Ado.SqlQuery<DataStockDetail>(str);
                var stockDetail = await Db.Queryable<DataStockDetail>().Where(s => s.IsDel == "0" && s.SkuNo == "100099" && s.Status == "0").ToListAsync();
                if (stockDetail.Count > 0)
                {
                    //判断是否大于需要垛数
                    if (stockDetail.Count < int.Parse(model.Num))
                    {
                        throw Oops.Bah("需要垛数大于库存垛数，请重新输入!");
                    }
                }
                //获取库存总表信息
                var stock = await Db.Queryable<DataStock>().FirstAsync(s => s.IsDel == "0" && s.SkuNo == "100099");
                //验证库存总表是否为空
                if (stock == null)
                {
                    throw Oops.Bah("库存信息不存在，请核查!");
                }

                int i = 0;

                Db.BeginTran();

                //遍历库存信息 
                foreach (var s in stockDetail)
                {
                    //获取储位信息
                    var locat = await Db.Queryable<SysStorageLocat>().FirstAsync(l => l.LocatNo == s.LocatNo && l.IsDel == "0" && l.WareHouseNo == "W01");

                    if (locat != null)
                    {
                        if (locat.Status != "1")
                        {
                            continue;
                        }
                        //更改储位状态为出库中
                        locat.Status = "3"; //3 出库中
                        locat.UpdateTime = serverTime; //修改时间
                        locat.UpdateUser = userId; //修改人
                        //修改储位信息
                        await Db.Updateable(locat).ExecuteCommandAsync();
                    }

                    //增加库存锁定数量
                    //stock.AllotQty +=
                    stock.LockQty += (int)s.Qty; //锁定数量
                    stock.UpdateTime = serverTime; //修改时间
                    stock.UpdateUser = userId; //修改人
                    //修改库存总表信息
                    await Db.Updateable(stock).ExecuteCommandAsync();

                    //增加库存明细锁定数量
                    //s.AllotQty += 
                    s.LockQty += (int)s.Qty; //锁定数量
                    s.UpdateTime = serverTime; //修改时间
                    s.UpdateUser = userId; //修改人
                    s.Status = "2"; //2 已分配
                    //修改库存明细信息
                    await Db.Updateable(s).ExecuteCommandAsync();

                    #region 分配

                    //添加分配表信息
                    var allot = new BllExportAllot
                    {
                        SONo = "",
                        WaveNo = "",
                        SODetailNo = 0,
                        StockId = s.Id,
                        LotNo = "",
                        LotText = "",
                        SupplierLot = "",
                        SkuNo = s.SkuNo,
                        SkuName = s.SkuName,
                        Standard = s.Standard,
                        PalletNo = s.PalletNo,
                        IsBale = "0", //是否裹包
                        IsBelt = "0", //是否打带

                        //BoxexQty = s.Qty,
                        Qty = (int)s.Qty,
                        CompleteQty = 0,
                        Status = "1",
                        LogisticsId = 0,
                        IsAdvance = "0",
                        OutMode = model.OutMode,//出库口

                        CreateUser = userId,
                        CreateTime = DateTime.Now
                    };
                    await Db.Insertable(allot).ExecuteCommandAsync();

                    #endregion

                    #region 添加出库任务信息

                    var taskNo = new Common().GetMaxNo("TK");
                    var exTask = new LogTask    //出库任务
                    {
                        TaskNo = taskNo,
                        Sender = "WMS",
                        Receiver = "PDA",
                        IsSuccess = 1, //是否下发成功 0失败 1成功

                        StartLocat = locat == null ? "零箱库" : s.LocatNo,//起始位置
                        EndLocat = model.OutMode,//目标位置
                        PalletNo = s.PalletNo,//托盘码
                        IsSend = 1,//是否可再次下发
                        IsCancel = 1,//是否可取消
                        IsFinish = 1,//是否可完成
                        Type = "1",//任务类型 0 入库任务 1 出库任务  2 移库任务
                        Status = "1",//任务状态0：等待执行1正在执行2执行完成
                        OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单
                        CreateTime = serverTime, //创建时间
                        CreateUser = userId, //创建人
                        Msg = "Pda空托从" + locat == null ? "零箱库" : s.LocatNo + "到" + model.OutMode + "的出库任务", //关键信息
                        //FinishDate = serverTime, //完成时间
                    };
                    outDtoList.Add(new OutCommandDto()
                    {
                        PalletNo = exTask.PalletNo,//托盘号
                        StartLocate = exTask.StartLocat, // 起始位置
                        StartRoadway = locat.RoadwayNo, //所属巷道
                        EndLocate = "", // 目标位置 
                        TaskNo = exTask.TaskNo, // 任务号
                        TaskType = "1",// 任务类型 (出库)
                        OutMode = model.OutMode,  //目标地址
                        Order = 1
                    });
                    await Db.Insertable(exTask).ExecuteCommandAsync();

                    #endregion
                    i += 1;
                    if (i == int.Parse(model.Num))
                    {
                        //需求垛数已达到 可以出库了
                        break;
                    }
                }

                if (outDtoList.Count > 0)
                {
                    // 正式运行程序放开
                    var list2 = outDtoList.Select(m => m.TaskNo).ToList();
                    var jsonData = JsonConvert.SerializeObject(outDtoList);
                    string response = "";

                    try
                    {
                        var time1 = DateTime.Now;//发送时间 .ToString("yyyy-MM-dd HH:mm:ss")
                        response = HttpHelper.DoPost(url, jsonData, "下发给WCS出库命令", "WCS");
                        var time2 = DateTime.Now;//返回时间 .ToString("yyyy-MM-dd HH:mm:ss")

                        ////解析返回数据 
                        var wcsModel = JsonConvert.DeserializeObject<WcsModel>(response);
                        if (wcsModel.StatusCode == 0)
                        {
                            //更改任务的发送返回时间//
                            new TaskServer().EditTaskIssueOk(list2, time1, time2);
                            //str += "下发成功";
                        }
                        if (wcsModel.StatusCode == -1)
                        {
                            new TaskServer().EditTaskIssueNo(list2, time1, time2, wcsModel.Msg);
                            throw Oops.Bah(wcsModel.Msg);
                        }
                    }
                    catch (AppFriendlyException e)
                    {
                        throw Oops.Bah(e.Message);
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(ex.Message);
                    }

                }

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "空托出库", i + "", "下发", $"用PDA下发了 {i} 个空托垛", userId);
                Db.CommitTran();

                return "";

            }
            catch (Exception e)
            {
                Db.RollbackTran();
                return "";
            }

        }

        //获取平库托盘信息
        public async Task<List<BoxInfo>> GetPingKuInfoByPallet(string soNo, string palletNo)
        {

            var info = Db.Queryable<BllExportAllot>()
                .LeftJoin<DataStockDetail>((a, b) => a.PalletNo == b.PalletNo)
                .Where(a=>a.IsDel == "0" && (a.Status == "0"||a.Status =="1") && a.SONo == soNo)
                .GroupBy((a,b) => new { a.SkuNo, a.SkuName, a.LotNo}).Select((a,b) => new BoxInfo()
                {
                    SkuNo = a.SkuNo,
                    SkuName = a.SkuName,
                    LotNo = a.LotNo
                }).ToListAsync();
            var data = await info;

            /*v var info = Db.Queryable<BllExportAllot>()
                .LeftJoin<DataStockDetail>((a, b) => a.PalletNo == b.PalletNo)
                .Where(a=>a.IsDel == "0" && (a.Status == "0"||a.Status =="1") && a.SONo == soNo)
                .GroupBy((a,b) => new { a.SkuNo, a.SkuName, a.LotNo, a.PalletNo,b.LocatNo }).Select((a,b) => new BoxInfo()
                {
                    PalletNo = a.PalletNo,
                    SkuNo = a.SkuNo,
                    SkuName = a.SkuName,
                    LotNo = a.LotNo,
                    LocatNo =  b.LocatNo
                }).ToListAsync();
            var data = await info;*/

            return data;
        }

        //获取平库单据中托盘位置信息
        public async Task<List<BoxInfo>> GetPingKuLocationInfo(string soNo,string skuno,string lotno)
        {

            var info = Db.Queryable<BllExportAllot>()
                .LeftJoin<DataStockDetail>((a, b) => a.PalletNo == b.PalletNo)
                .LeftJoin<SysWareHouse>((a,b,c)=>b.WareHouseNo == c.WareHouseNo)
                .LeftJoin<SysStorageArea>((a,b,c,d)=>b.AreaNo == d.AreaNo)
                .Where(a => a.IsDel == "0" && (a.Status == "0" || a.Status == "1") && a.SONo == soNo && a.SkuNo == skuno && a.LotNo == lotno)
                .GroupBy((a, b,c,d) => new { a.PalletNo, b.LocatNo,c.WareHouseName,d.AreaName }).Select((a, b,c,d) => new BoxInfo()
                {
                    PalletNo = a.PalletNo,
                    LocatNo = b.LocatNo,
                    WareHouseName = c.WareHouseName,
                    AreaName = d.AreaName
                }).ToListAsync();
            var data = await info;

            /*v var info = Db.Queryable<BllExportAllot>()
                .LeftJoin<DataStockDetail>((a, b) => a.PalletNo == b.PalletNo)
                .Where(a=>a.IsDel == "0" && (a.Status == "0"||a.Status =="1") && a.SONo == soNo)
                .GroupBy((a,b) => new { a.SkuNo, a.SkuName, a.LotNo, a.PalletNo,b.LocatNo }).Select((a,b) => new BoxInfo()
                {
                    PalletNo = a.PalletNo,
                    SkuNo = a.SkuNo,
                    SkuName = a.SkuName,
                    LotNo = a.LotNo,
                    LocatNo =  b.LocatNo
                }).ToListAsync();
            var data = await info;*/

            return data;
        }

        /// <summary>
        /// 平库出库完成
        /// </summary>
        /// <param name="soNo">单据号</param>
        /// <param name="palletNo">托盘码</param>
        /// <param name="userId">操作人</param>
        public async Task PlaneExportSuccess(string soNo, string palletNo, int userId)
        {
            #region 托盘信息

            //获取托盘信息
            var pallet = await Db.Queryable<SysPallets>().FirstAsync(p => p.IsDel == "0" && p.PalletNo == palletNo);
            //验证托盘信息是否为空
            if (pallet == null)
            {
                throw Oops.Bah("托盘信息不存在，请检查!");
            }
            if (pallet.Status == "0")
            {
                throw Oops.Bah("托盘未使用，请检查!");
            }
            #endregion

            #region 托盘是否在平库验证

            var result = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.PalletNo == palletNo);
            if (result == null)
            {
                throw Oops.Bah("库存信息中不存在该托盘信息，请检查!");
            }

            //if (result.WareHouseNo != "W02")//W02：零箱库
            //{
            //    throw Oops.Bah("该托盘未在零箱库，请检查!");
            //}

            #endregion

            #region 验证储位状态是否正常

            var locat = await Db.Queryable<SysStorageLocat>().FirstAsync(a => a.IsDel == "0" && a.LocatNo == result.LocatNo);
            if (locat == null)
            {
                throw Oops.Bah("未获取到对应储位信息，请检查!");
            }
            if (locat.Status != "3")
            {
                throw Oops.Bah("当前储位不是有物品，请检查!");
            }

            #endregion

            //获取库存明细信息
            var stockDetail = await Db.Queryable<DataStockDetail>().Where(s => s.IsDel == "0" && s.PalletNo == palletNo).ToListAsync();
            //验证库存明细信息是否存在
            if (stockDetail == null)
            {
                throw Oops.Bah("库存明细不存在，请检查库存信息!");
            }

            Db.BeginTran();

            try
            {
                foreach (var item in stockDetail)
                {
                    if (item.SkuNo == "100099")//判断是否是空托出库
                    {
                        //判断总库存是否为0，如果为0删除 否则减去数量
                        var stock = await Db.Queryable<DataStock>().FirstAsync(m => m.SkuNo == "100099");

                        if (stock != null)
                        {
                            if (item.LockQty != null)
                            {
                                stock.Qty -= item.LockQty.Value;
                                stock.LockQty -= item.LockQty.Value;
                                await Db.Updateable(stock).ExecuteCommandAsync();
                            }

                            if (stock.Qty == 0)
                            {
                                await Db.Deleteable(stock).ExecuteCommandAsync();
                            }
                        }

                        //托盘状态改为未使用
                        var sCode = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == item.PalletNo);
                        if (sCode != null)
                        {
                            sCode.Status = "0";
                            await Db.Updateable(sCode).ExecuteCommandAsync();
                        }
                        await Db.Deleteable(item).ExecuteCommandAsync();

                        continue;
                    }
                    item.LocatNo = "";//储位更改（改为空）
                    item.WareHouseNo = "";//所属仓库更改（改为空）
                    item.RoadwayNo = "";//所属巷道更改（改为空）
                    item.AreaNo = "";//所属区域更改（改为空）
                    await Db.Updateable(item).ExecuteCommandAsync();
                }
                //变更储位状态
                locat.Status = "0";//储位更改（改为空储位）
                await Db.Updateable(locat).ExecuteCommandAsync();

                //出库流水（更改状态）
                var allot = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.Status == "1" && m.PalletNo == palletNo && m.SONo == soNo).ToListAsync();

                foreach (var item in allot)
                {
                    if (item.SkuNo == "100099")
                    {
                        item.Status = "5";
                        item.CompleteQty += stockDetail[0].Qty;
                    }
                    else
                    {
                        item.Status = "2";
                    }

                }
                await Db.Updateable(allot).ExecuteCommandAsync();

                #region 添加出库操作日志记录信息

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("出库作业", "拣货明细", soNo, "完成", $"用PDA完成了单据号为{soNo}的平库出库", userId);

                #endregion

                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        //根据托盘号获取取样类型
        public async Task<string> GetSampleType(string palletNo)
        {
            var type = "";
            var detail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
            if (detail == null)
            {
                throw Oops.Bah("当前托盘未在库存中");
            }
            //怎么判断当前托盘是库外要取样的托盘，正常出库剩余托盘目前这种情况也能拣货啊，也没有分配信息
            var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
            if (allot != null)
            {
                var soNo = await Db.Queryable<BllExportNotice>()
                    .FirstAsync(m => m.IsDel == "0" && m.SONo == allot.SONo);
                if (soNo == null)
                {
                    throw Oops.Bah("未找到托盘上出库单据信息");
                }
                if (soNo.Type != "3")
                {
                    throw Oops.Bah("该托盘不是取样托盘");
                }
                type = "0";//库内取样
            }
            else
            {
                //判断当前托盘是否是在平库或库外
                type = "1";//库前取样
            }
            return type;
        }

        //根据托盘号获取入库单据
        public async Task<List<string>> GetAsnNoByPallet(string palletNo)
        {
            var type = "";
            var detail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
            if (detail == null)
            {
                throw Oops.Bah("当前托盘未在库存中");
            }

            var list = new List<string>();
            if (string.IsNullOrWhiteSpace(detail.ASNNo))
            {
                throw Oops.Bah("未查询到该托盘的入库单信息");
            }
            list.Add(detail.ASNNo);
            return list;
        }

        //取样出库拣货(标签)
        public async Task SampleSoSetPick(string soType, string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, 
            string pickQty1, string asnNo, int userId)
        {
            Db.BeginTran();
            try
            {
                if (string.IsNullOrWhiteSpace(soType))
                {
                    throw Oops.Bah("取样标识不能为空");
                }

                //soType: 0库内取样，有出库单及分配信息； 1库前取样，反向添加出库单及分配信息
                if (soType == "1")
                {

                    #region 判断

                    if (string.IsNullOrWhiteSpace(asnNo))
                    {
                        throw Oops.Bah("入库单不能为空");
                    }
                    if (string.IsNullOrWhiteSpace(palletNo))
                    {
                        throw Oops.Bah("托盘码不能为空");
                    }
                    if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
                    {
                        throw Oops.Bah("追溯条码和拣货数量不能同时输入");
                    }
                    //先判断是否是库外取样托盘
                    var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                        m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
                    if (allot != null)
                    {
                        throw Oops.Bah("当前托盘不属于库前取样");
                    }


                    //库存明细
                    var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == asnNo && m.PalletNo == palletNo);
                    if (stockDetail == null)
                    {
                        throw Oops.Bah("未查询到该托盘的库存明细信息！");
                    }

                    var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == stockDetail.SkuNo);
                    if (sku == null)
                    {
                        throw Oops.Bah("未查询到当前托盘上的物料信息");
                    }
                    //库存总表
                    var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                    if (stock == null)
                    {
                        throw Oops.Bah("未查询到该托盘分配的库存信息！");
                    }

                    //出库单
                    var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.AsnSampleNo == asnNo);
                    //创建出库单
                    if (notice == null || notice.Status == "6")
                    {
                        var billNo = "";
                        var bl = true;
                        do
                        {
                            //获取自增单据号
                            billNo = new Common().GetMaxNo("SO");
                            var no = billNo;
                            bl = await Db.Queryable<BllExportNotice>().AnyAsync(m => m.SONo == no);
                        } while (bl);


                        var addNotice = new BllExportNotice()
                        {
                            SONo = billNo,
                            Type = "3",
                            Status = "4",
                            Origin = "WMS",
                            AsnSampleNo = asnNo,
                            IsWave = "0",
                            WaveNo = "",
                            IsDespatch = "0",
                            CompleteTime = DateTime.Now,
                            CreateUser = userId,
                        };

                        var n = await Db.Insertable(addNotice).ExecuteReturnEntityAsync();
                        notice = n;
                    }

                    //创建出库单明细
                    var noticeDetail = await Db.Queryable<BllExportNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.SONo == notice.SONo && m.SkuNo == stockDetail.SkuNo && m.LotNo.Contains(stockDetail.LotNo));
                    if (noticeDetail == null)
                    {
                        var addNoticeDetail = new BllExportNoticeDetail()
                        {
                            SONo = notice.SONo,
                            SkuNo = sku.SkuNo,
                            SkuName = sku.SkuName,
                            Standard = sku.Standard,
                            LotNo = stockDetail.LotNo,
                            LotText = "",
                            Qty = 0,
                            AllotQty = 0,
                            FactQty = 0,
                            CompleteQty = 0,
                            PackagNo = sku.PackagNo,
                            Price = sku.Price,
                            //Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * pickQty,
                            IsBale = "",
                            IsBelt = "",
                            SupplierLot = stock.SupplierLot,
                            IsWave = "0",
                            WaveNo = "",
                            IsIssueLotNo = "0",
                            Status = "3",
                            CreateUser = userId,

                        };
                        var m = await Db.Insertable(addNoticeDetail).ExecuteReturnEntityAsync();
                        noticeDetail = m;
                    }
                    //出库分配信息
                    var allot2 = await Db.Queryable<BllExportAllot>().FirstAsync(m => m.IsDel == "0" && m.Status == "5" && m.SONo == notice.SONo && m.PalletNo == palletNo);
                    if (allot2 == null)
                    {
                        //添加分配表信息
                        var addAllot = new BllExportAllot
                        {
                            SONo = notice.SONo,
                            WaveNo = "",
                            SODetailNo = noticeDetail.Id,
                            StockId = stockDetail.Id,
                            LotNo = stockDetail.LotNo,
                            LotText = stockDetail.LotText,
                            SupplierLot = stockDetail.SupplierLot,
                            SkuNo = sku.SkuNo,
                            SkuName = sku.SkuName,
                            Standard = sku.Standard,
                            PalletNo = palletNo,
                            IsBale = "0", //是否裹包
                            IsBelt = "0", //是否打带

                            Qty = 0,
                            CompleteQty = 0,

                            Status = "5",
                            LogisticsId = notice.LogisticsId,
                            IsAdvance = "0",
                            OutMode = "",//出库口

                            CreateUser = userId,
                            UpdateTime = DateTime.Now
                        };

                        var fp = await Db.Insertable(addAllot).ExecuteReturnEntityAsync();
                        allot2 = fp;
                    }


                    #endregion


                    //判断是散支拣货还是数量拣货
                    var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
                    if (await boxInfo.CountAsync() == 0)
                    {
                        throw Oops.Bah("未查询到该箱码及追溯码的信息");
                    }
                    boxInfos = await boxInfo.ToListAsync();
                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot2.Id && m.PalletNo == palletNo).ToListAsync();
                    if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
                    {
                        boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

                        if (boxInfos.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码及追溯码的信息");
                        }
                        if (boxInfos.Count() > 1)
                        {
                            throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
                        }

                        if (boxInfos.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                            }
                        }
                        biaoShi = "1";
                    }
                    else if (!string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)//数量拣货
                    {
                        if (boxInfo.Count() > 1)
                        {
                            throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
                        }
                        decimal boxQty = boxInfo.First().Qty;
                        if (Convert.ToInt32(pickQty1) > boxQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }

                        biaoShi = "2";
                    }
                    else //整箱拣货
                    {
                        if (boxInfo.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码的信息");
                        }
                        if (boxInfo.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
                            }
                        }
                    }
                    decimal pickQty = 0;//拣货的数量

                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        //if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                        //{
                        //    throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                        //}
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = notice.SONo,
                            SODetailNo = noticeDetail.Id,
                            ExportAllotId = allot2.Id,
                            StockId = allot2.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot2.LotNo,
                            LotText = allot2.LotText,
                            SupplierLot = allot2.SupplierLot,
                            SkuNo = allot2.SkuNo,
                            SkuName = allot2.SkuName,
                            Standard = allot2.Standard,
                            PalletNo = palletNo,
                            CompleteQty = biaoShi == "2" ? decimal.Parse(pickQty1) : item.Qty,
                            InspectMark = "1",

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        if (biaoShi != "2")
                        {
                            //删除库存箱码明细
                            await Db.Deleteable(item).ExecuteCommandAsync();
                        }
                        else//数量拣货
                        {
                            if (decimal.Parse(pickQty1) == item.Qty)
                            {
                                //删除库存箱码明细
                                await Db.Deleteable(item).ExecuteCommandAsync();
                            }
                            else
                            {
                                item.Qty -= decimal.Parse(pickQty1);
                                item.BitBoxMark = "1";//零箱标识
                                item.InspectMark = "1";//抽检箱标识
                                await Db.Updateable(item).ExecuteCommandAsync();
                            }
                        }
                        pickQty += biaoShi == "2" ? decimal.Parse(pickQty1) : item.Qty;
                    }


                    //改变库内箱码是否零箱信息
                    if (biaoShi == "1")
                    {
                        var boxSurplusList = boxInfo.Where(m => m.BoxNo3 != boxNo3).ToList();
                        foreach (var item in boxSurplusList)
                        {
                            item.BitBoxMark = "1";
                            item.InspectMark = "1";
                            await Db.Updateable(item).ExecuteCommandAsync();
                        }
                    }

                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot2.Qty += pickQty;
                    allot2.CompleteQty += pickQty;
                    await Db.Updateable(allot2).ExecuteCommandAsync();

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.Qty -= pickQty;

                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                    stock.Qty -= pickQty;
                    if (stock.Qty <= 0)
                    {
                        await Db.Deleteable(stock).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stock).ExecuteCommandAsync();
                    }
                    var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
                    if (num2 <= 0)
                    {
                        //改变托盘状态
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }
                    //修改出库单明细拣货数量
                    noticeDetail.Qty += pickQty;
                    noticeDetail.AllotQty += pickQty;
                    noticeDetail.FactQty += pickQty;
                    noticeDetail.CompleteQty += pickQty;
                    noticeDetail.Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * noticeDetail.Qty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                }
                else if (soType == "0")
                {
                    #region 判断

                    if (string.IsNullOrWhiteSpace(soNo))
                    {
                        throw Oops.Bah("出库单据不能为空");
                    }
                    if (string.IsNullOrWhiteSpace(soDetailId))
                    {
                        throw Oops.Bah("出库物料-批次不能为空");
                    }
                    if (string.IsNullOrWhiteSpace(palletNo))
                    {
                        throw Oops.Bah("托盘码不能为空");
                    }
                    if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
                    {
                        throw Oops.Bah("追溯条码和拣货数量不能同时输入");
                    }

                    //出库单
                    var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                    if (notice == null)
                    {
                        throw Oops.Bah("未查询到该出库单的信息");
                    }
                    if (notice.Status != "3")
                    {
                        throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                    }
                    //出库单明细
                    var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                        .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                    if (noticeDetail == null)
                    {
                        throw Oops.Bah("未查询到该出库单明细的信息");
                    }
                    //出库分配信息
                    var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                        m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                        m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                    if (allot == null)
                    {
                        throw Oops.Bah("未查询到该托盘的分配信息");
                    }
                    //剩余拣货数量（待拣减去已拣）
                    var needQty = allot.Qty - allot.CompleteQty;

                    //库存明细
                    var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                    if (stockDetail == null)
                    {
                        throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                    }
                    //库存总表
                    var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                    if (stock == null)
                    {
                        throw Oops.Bah("未查询到该托盘分配的库存信息！");
                    }

                    #endregion

                    var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
                    if (await boxInfo.CountAsync() == 0)
                    {
                        throw Oops.Bah("未查询到该箱码及追溯码的信息");
                    }
                    boxInfos = await boxInfo.ToListAsync();
                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
                    if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
                    {
                        boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

                        if (boxInfos.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码及追溯码的信息");
                        }
                        if (boxInfos.Count() > 1)
                        {
                            throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
                        }

                        if (boxInfos.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = boxInfos.First().Qty;
                        if (boxQty > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于剩余待拣数量");
                        }
                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                            }
                        }
                        biaoShi = "1";
                    }
                    else if (!string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)//数量拣货
                    {
                        if (boxInfo.Count() > 1)
                        {
                            throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
                        }
                        decimal boxQty = boxInfo.First().Qty;
                        if (Convert.ToInt32(pickQty1) > boxQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }
                        if (Convert.ToInt32(pickQty1) > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于剩余待拣数量");
                        }

                        biaoShi = "2";
                    }
                    else //整箱拣货
                    {
                        if (boxInfo.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码的信息");
                        }
                        if (boxInfo.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
                        if (boxQty[0] > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                        }
                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
                            }
                        }
                    }
                    decimal pickQty = 0;//拣货的数量

                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        //if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                        //{
                        //    throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                        //}
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = biaoShi == "2" ? decimal.Parse(pickQty1) : item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        if (biaoShi != "2")
                        {
                            //删除库存箱码明细
                            await Db.Deleteable(item).ExecuteCommandAsync();
                        }
                        else//数量拣货
                        {
                            if (decimal.Parse(pickQty1) == item.Qty)
                            {
                                //删除库存箱码明细
                                await Db.Deleteable(item).ExecuteCommandAsync();
                            }
                            else
                            {
                                item.Qty -= decimal.Parse(pickQty1);
                                item.BitBoxMark = "1";//零箱标识
                                item.InspectMark = "1"; //抽检箱标识
                                await Db.Updateable(item).ExecuteCommandAsync();
                            }
                        }
                        pickQty += item.Qty;
                    }
                    //改变库内箱码是否零箱信息
                    if (biaoShi == "1")
                    {
                        var boxSurplusList = boxInfo.Where(m => m.BoxNo3 != boxNo3).ToList();
                        foreach (var item in boxSurplusList)
                        {
                            item.BitBoxMark = "1";
                            await Db.Updateable(item).ExecuteCommandAsync();
                        }
                    }

                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    if (allot.Status == "5")
                    {
                        //判断该托盘是否还存在物料 存在改为待回库 待回库完成后改为已完成
                    }
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.InspectMark = "1"; //抽检托标识
                    stockDetail.Qty -= pickQty;
                    stockDetail.LockQty -= pickQty;
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }

                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                    stock.Qty -= pickQty;
                    stock.LockQty -= pickQty;
                    stock.IsSampling = "1";
                    if (stock.Qty <= 0)
                    {
                        await Db.Deleteable(stock).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stock).ExecuteCommandAsync();
                    }
                    var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
                    if (num2 <= 0)
                    {
                        //改变托盘状态
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }
                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = await Db.Queryable<BllExportNoticeDetail>()
                        .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();
                }
                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货出库", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        //取样出库拣货(无标签)
        public async Task SampleSoSetQtyPick(string soType, string soNo, string soDetailId, string palletNo, string PickQty, string asnNo, int userId)
        {
            Db.BeginTran();
            try
            {
                if (string.IsNullOrWhiteSpace(soType))
                {
                    throw Oops.Bah("取样标识不能为空");
                }

                if (soType == "1")
                {
                    if (string.IsNullOrWhiteSpace(asnNo))
                    {
                        throw Oops.Bah("入库单据不能为空");
                    }
                    if (string.IsNullOrWhiteSpace(palletNo))
                    {
                        throw Oops.Bah("托盘码不能为空");
                    }
                    //先判断是否是库外取样托盘
                    var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                        m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
                    if (allot != null)
                    {
                        throw Oops.Bah("当前托盘不属于库前取样");
                    }


                    //库存明细
                    var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == asnNo && m.PalletNo == palletNo);
                    if (stockDetail == null)
                    {
                        throw Oops.Bah("未查询到该托盘的库存明细信息！");
                    }

                    var sku = await Db.Queryable<SysMaterials>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == stockDetail.SkuNo);
                    if (sku == null)
                    {
                        throw Oops.Bah("未查询到当前托盘上的物料信息");
                    }
                    //库存总表
                    var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                    if (stock == null)
                    {
                        throw Oops.Bah("未查询到该托盘分配的库存信息！");
                    }

                    //出库单
                    var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.AsnSampleNo == asnNo);
                    //创建出库单
                    if (notice == null || notice.Status == "6")
                    {
                        var billNo = "";
                        var bl = true;
                        do
                        {
                            //获取自增单据号
                            billNo = new Common().GetMaxNo("SO");
                            var no = billNo;
                            bl = await Db.Queryable<BllExportNotice>().AnyAsync(m => m.SONo == no);
                        } while (bl);

                        var addNotice = new BllExportNotice()
                        {
                            SONo = billNo,
                            Type = "3",
                            Status = "4",
                            Origin = "WMS",
                            AsnSampleNo = asnNo,
                            IsWave = "0",
                            WaveNo = "",
                            IsDespatch = "0",
                            CompleteTime = DateTime.Now,
                            CreateUser = userId,
                        };

                        var n = await Db.Insertable(addNotice).ExecuteReturnEntityAsync();
                        notice = n;
                    }

                    //创建出库单明细
                    var noticeDetail = await Db.Queryable<BllExportNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.SONo == notice.SONo && m.SkuNo == stockDetail.SkuNo && m.LotNo.Contains(stockDetail.LotNo));
                    if (noticeDetail == null)
                    {
                        var addNoticeDetail = new BllExportNoticeDetail()
                        {
                            SONo = notice.SONo,
                            SkuNo = sku.SkuNo,
                            SkuName = sku.SkuName,
                            Standard = sku.Standard,
                            LotNo = stockDetail.LotNo,
                            LotText = "",
                            Qty = 0,
                            AllotQty = 0,
                            FactQty = 0,
                            CompleteQty = 0,
                            PackagNo = sku.PackagNo,
                            Price = sku.Price,
                            //Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * pickQty,
                            IsBale = "",
                            IsBelt = "",
                            SupplierLot = stock.SupplierLot,
                            IsWave = "0",
                            WaveNo = "",
                            IsIssueLotNo = "0",
                            Status = "3",
                            CreateUser = userId,

                        };
                        var m = await Db.Insertable(addNoticeDetail).ExecuteReturnEntityAsync();
                        noticeDetail = m;
                    }
                    //出库分配信息
                    var allot2 = await Db.Queryable<BllExportAllot>().FirstAsync(m => m.IsDel == "0" && m.Status == "5" && m.SONo == notice.SONo && m.PalletNo == palletNo);
                    if (allot2 == null)
                    {
                        //添加分配表信息
                        var addAllot = new BllExportAllot
                        {
                            SONo = notice.SONo,
                            WaveNo = "",
                            SODetailNo = noticeDetail.Id,
                            StockId = stockDetail.Id,
                            LotNo = stockDetail.LotNo,
                            LotText = stockDetail.LotText,
                            SupplierLot = stockDetail.SupplierLot,
                            SkuNo = sku.SkuNo,
                            SkuName = sku.SkuName,
                            Standard = sku.Standard,
                            PalletNo = palletNo,
                            IsBale = "0", //是否裹包
                            IsBelt = "0", //是否打带

                            Qty = 0,
                            CompleteQty = 0,

                            Status = "5",
                            LogisticsId = notice.LogisticsId,
                            IsAdvance = "0",
                            OutMode = "",//出库口

                            CreateUser = userId,
                            UpdateTime = DateTime.Now
                        };

                        var fp = await Db.Insertable(addAllot).ExecuteReturnEntityAsync();
                        allot2 = fp;
                    }

                    //获取当前托盘拣货明细
                    var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.ExportAllotId == allot2.Id && a.StockId == stockDetail.Id);

                    //判读是否存在拣货明细
                    int isComplete = 0;
                    if (complete != null)
                    {
                        isComplete = 1;
                    }

                    var comList = new List<BllCompleteDetail>();
                    //判断是否存在拣货明细
                    if (isComplete == 0)
                    {
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = notice.SONo,
                            SODetailNo = noticeDetail.Id,
                            ExportAllotId = allot2.Id,
                            StockId = allot2.StockId,
                            BoxNo = "",
                            BoxNo2 = "",
                            BoxNo3 = "",

                            LotNo = allot2.LotNo,
                            LotText = allot2.LotText,
                            SupplierLot = allot2.SupplierLot,
                            SkuNo = allot2.SkuNo,
                            SkuName = allot2.SkuName,
                            Standard = allot2.Standard,
                            PalletNo = palletNo,
                            CompleteQty = int.Parse(PickQty),
                            InspectMark = "1",

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        //添加拣货明细
                        await Db.Insertable(comList).ExecuteCommandAsync();
                    }
                    else if (isComplete == 1)
                    {
                        complete.CompleteQty += int.Parse(PickQty);
                        complete.UpdateUser = userId;
                        complete.UpdateTime = Db.GetDate();

                        await Db.Updateable(complete).ExecuteCommandAsync();
                    }



                    //修改出库分配信息
                    allot2.Qty += int.Parse(PickQty);
                    allot2.CompleteQty += int.Parse(PickQty);
                    await Db.Updateable(allot2).ExecuteCommandAsync();

                    int isDel = 0;

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.InspectMark = "1";//修改为抽检托标识
                    stockDetail.Qty -= int.Parse(PickQty);
                    if (stockDetail.Qty == stockDetail.LockQty && stockDetail.Qty != 0)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }
                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        isDel = 1;
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                    //删除或修改库存
                    stock.Qty -= int.Parse(PickQty);
                    if (stock.Qty <= 0)
                    {
                        await Db.Deleteable(stock).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stock).ExecuteCommandAsync();
                    }

                    //改变托盘状态为：未使用
                    var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                    if (pallet == null)
                    {
                        throw Oops.Bah("未在托盘表中查询到托盘信息");
                    }

                    //判断托盘上物料是否拣货完毕
                    if (isDel == 0)
                    {
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }

                    //修改出库单明细拣货数量
                    noticeDetail.Qty += int.Parse(PickQty);
                    noticeDetail.AllotQty += int.Parse(PickQty);
                    noticeDetail.FactQty += int.Parse(PickQty);
                    noticeDetail.CompleteQty += int.Parse(PickQty);
                    noticeDetail.Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * noticeDetail.Qty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                }
                else if (soType == "0")
                {
                    #region 判断

                    if (string.IsNullOrWhiteSpace(soNo))
                    {
                        throw Oops.Bah("出库单据不能为空");
                    }
                    //if (string.IsNullOrWhiteSpace(soDetailId))
                    //{
                    //    throw new Exception("出库物料-批次不能为空");
                    //}
                    if (string.IsNullOrWhiteSpace(palletNo))
                    {
                        throw Oops.Bah("托盘码不能为空");
                    }

                    //出库单
                    var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
                    if (notice == null)
                    {
                        throw Oops.Bah("未查询到该出库单的信息");
                    }
                    if (notice.Status != "3")
                    {
                        throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                    }
                    //出库单明细
                    var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
                        .First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                    if (noticeDetail == null)
                    {
                        throw Oops.Bah("未查询到该出库单明细的信息");
                    }
                    //出库分配信息
                    var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                        m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                        m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                    if (allot == null)
                    {
                        throw Oops.Bah("未查询到该托盘的分配信息");
                    }
                    //剩余拣货数量（待拣减去已拣）
                    var needQty = allot.Qty - allot.CompleteQty;
                    if (int.Parse(PickQty) > needQty)
                    {
                        throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
                    }

                    //库存明细
                    var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                    if (stockDetail == null)
                    {
                        throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                    }
                    //库存总表
                    var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                    if (stock == null)
                    {
                        throw Oops.Bah("未查询到该托盘分配的库存信息！");
                    }
                    #endregion
                    //获取当前托盘拣货明细
                    var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

                    //判读是否存在拣货明细
                    int isComplete = 0;
                    if (complete != null)
                    {
                        isComplete = 1;
                    }

                    var comList = new List<BllCompleteDetail>();
                    //判断是否存在拣货明细
                    if (isComplete == 0)
                    {
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = "",
                            BoxNo2 = "",
                            BoxNo3 = "",

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = int.Parse(PickQty),

                            CreateUser = userId,
                            CreateTime = Db.GetDate(),
                        };
                        comList.Add(completeDetail);

                        //添加拣货明细
                        await Db.Insertable(comList).ExecuteCommandAsync();
                    }
                    else if (isComplete == 1)
                    {
                        complete.CompleteQty += int.Parse(PickQty);
                        complete.UpdateUser = userId;
                        complete.UpdateTime = Db.GetDate();

                        await Db.Updateable(complete).ExecuteCommandAsync();
                    }



                    //修改出库分配信息
                    allot.CompleteQty += int.Parse(PickQty);
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";

                    allot.UpdateTime = DateTime.Now;
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    int isDel = 0;

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.InspectMark = "1"; //抽检托标识
                    stockDetail.Qty -= int.Parse(PickQty);
                    stockDetail.LockQty -= int.Parse(PickQty);
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }
                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        isDel = 1;
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                    //删除或修改库存
                    stock.Qty -= int.Parse(PickQty);
                    stock.LockQty -= int.Parse(PickQty);
                    stock.IsSampling = "1"; //是否取样
                    if (stock.Qty <= 0)
                    {
                        await Db.Deleteable(stock).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stock).ExecuteCommandAsync();
                    }

                    //改变托盘状态为：未使用
                    var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                    if (pallet == null)
                    {
                        throw Oops.Bah("未在托盘表中查询到托盘信息");
                    }

                    //判断托盘上物料是否拣货完毕
                    if (isDel == 0)
                    {
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }

                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += int.Parse(PickQty);
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = await Db.Queryable<BllExportNoticeDetail>()
                        .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();

                }

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货出库", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        #region 拣货拼托
        /// <summary>
        /// 拼托出库pda拣货-标签
        /// </summary>
        /// <param name="soNo"></param>
        /// <param name="soDetailId"></param>
        /// <param name="palletNo"></param>
        /// <param name="boxNo"></param>
        /// <param name="boxNo3"></param>
        /// <param name="pickQty1"></param>
        /// <param name="palletNoNew"></param>
        /// <param name="userId"></param>
        public async Task SoSetPinPick(string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, string palletNoNew, int userId)
        {
            Db.BeginTran();
            try
            {
                var nowDate = DateTime.Now;//当前时间
                #region 判断

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw Oops.Bah("出库单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(soDetailId))
                {
                    throw Oops.Bah("出库物料-批次不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘码不能为空");
                }
                if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
                {
                    throw Oops.Bah("追溯条码和拣货数量不能同时输入");
                }
                if (string.IsNullOrWhiteSpace(palletNoNew))
                {
                    throw Oops.Bah("新托盘码不能为空");
                }
                if (palletNo == palletNoNew)//原托盘与新托盘一致
                {
                    if (!string.IsNullOrEmpty(boxNo))
                    {
                        throw Oops.Bah("原托盘与新托盘一致，请选择整托出库");
                    }
                }

                //出库单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                    .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw Oops.Bah("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                    m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                    m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                if (allot == null)
                {
                    throw Oops.Bah("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;

                //库存明细
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存信息！");
                }

                #endregion

                #region 拼托信息
                var sdId = 0;
                bool isNew = false;
                var pinStockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew);
                if (pinStockDetail != null)
                {
                    if (palletNo != palletNoNew)//非整托拣货
                    {
                        if (pinStockDetail.SONo != notice.SONo)
                        {
                            throw Oops.Bah("拼托托盘上只能放同一个出库单下的物料！");
                        }
                        if (pinStockDetail.SkuName != stockDetail.SkuName || pinStockDetail.LotNo != stockDetail.LotNo)
                        {
                            isNew = true;
                        }
                    }
                    sdId = pinStockDetail.Id;
                }
                else
                {
                    isNew = true;

                    var newPalletInfo = await Db.Queryable<SysPallets>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
                    if (newPalletInfo == null)
                    {
                        throw Oops.Bah("新托盘信息不存在或已被使用！");
                    }
                    //修改新托盘状态
                    newPalletInfo.Status = "1";
                    await Db.Updateable(newPalletInfo).ExecuteCommandAsync();
                }
                var sd = new DataStockDetail();
                if (isNew)
                {
                    sd.LotNo = stockDetail.LotNo;
                    sd.LotText = stockDetail.LotText;
                    sd.SupplierLot = stockDetail.SupplierLot;
                    sd.SkuNo = stockDetail.SkuNo;
                    sd.SkuName = stockDetail.SkuName;
                    sd.Standard = stockDetail.Standard;

                    sd.FrozenQty = 0;
                    sd.InspectQty = 0;
                    sd.ASNNo = "";
                    sd.ASNDetailNo = null;
                    sd.SONo = soNo;//出库单号
                    sd.WareHouseNo = "";
                    sd.RoadwayNo = "";
                    sd.AreaNo = "";
                    sd.LocatNo = "";
                    sd.PalletNo = palletNoNew;
                    sd.PalletNo2 = "";
                    sd.PalletNo3 = "";
                    //PalletType = item.PalletType,
                    sd.CompleteTime = nowDate;
                    sd.ProductionTime = stockDetail.ProductionTime;
                    sd.ExpirationTime = stockDetail.ExpirationTime;
                    sd.Status = "2";//状态，已分配
                    sd.InspectMark = stockDetail.InspectMark;
                    sd.InspectStatus = stockDetail.InspectStatus;
                    sd.BitPalletMark = "0";
                    sd.PackagNo = noticeDetail.PackagNo;
                    sd.IsBale = stockDetail.IsBale;
                    sd.IsBelt = stockDetail.IsBelt;
                    sd.Demo = stockDetail.Demo;
                    sd.OwnerName = stockDetail.OwnerName;
                    sd.OwnerNo = stockDetail.OwnerNo;
                    sd.SupplierName = stockDetail.SupplierName;
                    sd.SupplierNo = stockDetail.SupplierNo;

                    sd.IsDel = "0";
                    sd.CreateUser = userId;
                    sd.CreateTime = nowDate;

                    //新增拼托库存明细信息
                    sdId = await Db.Insertable(sd).ExecuteReturnIdentityAsync();
                }
                #endregion

                decimal pickQty = 0;//拣货的数量
                if (string.IsNullOrWhiteSpace(boxNo))//整托拣货
                {
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo);//找到托盘上所有箱码
                    boxInfos = await boxInfo.ToListAsync();
                    if (boxInfo.Count() <= 0)
                    {
                        throw Oops.Bah("该托盘上没有可拣货的箱子");
                    }
                    var boxQty = await boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
                    if (boxQty[0] > needQty)
                    {
                        throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                    }

                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        if (comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                        {
                            throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                        }
                        if (item.SkuNo != allot.SkuNo || item.LotNo != allot.LotNo)
                        {
                            throw Oops.Bah("当前托盘上有其他不同物料批次，拣货失败");
                        }
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        if (palletNo != palletNoNew)
                        {
                            item.StockDetailId = sdId;
                            item.BindNo = null;//托盘绑定号
                            item.PalletNo = palletNoNew;
                        }
                        item.Status = "5";//箱支状态，0：未组托  1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
                        //修改库存箱码明细
                        await Db.Updateable(item).ExecuteCommandAsync();

                        pickQty += item.Qty;
                    }
                    //添加拣货明细
                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    if (palletNo != palletNoNew)
                    {
                        //删除原托盘库存明细
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();

                        //改变原托盘状态为：未使用
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }
                    else
                    {
                        stockDetail.SONo = soNo;
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }

                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = Db.Queryable<BllExportNoticeDetail>()
                        .Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();
                }
                else
                {
                    var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
                    if (await boxInfo.CountAsync() == 0)
                    {
                        throw Oops.Bah("未查询到该箱码及追溯码的信息");
                    }
                    boxInfos = await boxInfo.ToListAsync();

                    var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
                    if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
                    {
                        boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

                        if (boxInfos.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码及追溯码的信息");
                        }
                        if (boxInfos.Count() > 1)
                        {
                            throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
                        }

                        if (boxInfos.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = boxInfos.First().Qty;
                        if (boxQty > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于剩余待拣数量");
                        }

                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                            }
                        }

                        biaoShi = "1";
                    }
                    else if (!string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)//数量拣货
                    {
                        if (boxInfo.Count() > 1)
                        {
                            throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
                        }
                        decimal boxQty = boxInfo.First().Qty;
                        if (Convert.ToInt32(pickQty1) > boxQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }
                        if (Convert.ToInt32(pickQty1) > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于剩余待拣数量");
                        }

                        biaoShi = "2";
                    }
                    else //整箱拣货
                    {
                        if (boxInfo.Count() == 0)
                        {
                            throw Oops.Bah("未查询到该箱码的信息");
                        }
                        if (boxInfo.Any(m => m.PalletNo != palletNo))
                        {
                            throw Oops.Bah("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = await boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
                        if (boxQty[0] > needQty)
                        {
                            throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
                        }

                        foreach (var item in boxInfos)
                        {
                            if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
                            {
                                throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
                            }
                        }
                    }

                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        //添加拣货明细
                        var completeDetail = new BllCompleteDetail()
                        {
                            SONo = soNo,
                            SODetailNo = int.Parse(soDetailId),
                            ExportAllotId = allot.Id,
                            StockId = allot.StockId,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,

                            LotNo = allot.LotNo,
                            LotText = allot.LotText,
                            SupplierLot = allot.SupplierLot,
                            SkuNo = allot.SkuNo,
                            SkuName = allot.SkuName,
                            Standard = allot.Standard,
                            PalletNo = palletNo,
                            CompleteQty = biaoShi == "2" ? decimal.Parse(pickQty1) : item.Qty,

                            CreateUser = userId
                        };
                        comList.Add(completeDetail);

                        if (biaoShi == "0")//整箱拣货
                        {
                            //修改库存箱码明细
                            item.StockDetailId = sdId;
                            item.BindNo = null;//托盘绑定号
                            item.PalletNo = palletNoNew;
                            item.Status = "5";//箱支状态，0：未组托  1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
                            await Db.Updateable(item).ExecuteCommandAsync();

                            pickQty += item.Qty;
                        }
                        else if (biaoShi == "1")//散支拣货
                        {
                            //修改库存箱码明细
                            item.StockDetailId = sdId;
                            item.BindNo = null;//托盘绑定号
                            item.PalletNo = palletNoNew;
                            item.BoxNo = item.BoxNo3;//将支码赋给箱码
                            item.BitBoxMark = "1";//零箱标记
                            item.Status = "5";//箱支状态，0：未组托  1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
                            await Db.Updateable(item).ExecuteCommandAsync();

                            pickQty += item.Qty;
                        }
                        else//数量拣货
                        {
                            if (decimal.Parse(pickQty1) == item.Qty)
                            {
                                //修改库存箱码明细
                                item.StockDetailId = sdId;
                                item.BindNo = null;//托盘绑定号
                                item.PalletNo = palletNoNew;
                                item.Status = "5";//箱支状态，0：未组托  1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
                                await Db.Updateable(item).ExecuteCommandAsync();
                            }
                            else
                            {
                                item.Qty -= decimal.Parse(pickQty1);
                                item.BitBoxMark = "1";//零箱标识
                                await Db.Updateable(item).ExecuteCommandAsync();
                            }

                            pickQty += int.Parse(pickQty1);
                        }
                    }
                    //改变库内箱码是否零箱信息
                    if (biaoShi == "1")
                    {
                        var boxSurplusList = boxInfo.Where(m => m.BoxNo3 != boxNo3).ToList();
                        foreach (var item in boxSurplusList)
                        {
                            item.BitBoxMark = "1";
                            await Db.Updateable(item).ExecuteCommandAsync();
                        }
                    }

                    await Db.Insertable(comList).ExecuteCommandAsync();
                    //修改出库分配信息
                    allot.CompleteQty += pickQty;
                    allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                    allot.UpdateTime = DateTime.Now;
                    if (allot.Status == "5")
                    {
                        //判断该托盘是否还存在物料 存在改为待回库 待回库完成后改为已完成
                    }
                    await Db.Updateable(allot).ExecuteCommandAsync();

                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.Qty -= pickQty;
                    stockDetail.LockQty -= pickQty;
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }

                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                    var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
                    if (num2 <= 0)
                    {
                        //改变托盘状态
                        var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw Oops.Bah("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        await Db.Updateable(pallet).ExecuteCommandAsync();
                    }
                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                    var num = await Db.Queryable<BllExportNoticeDetail>()
                        .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    await Db.Updateable(notice).ExecuteCommandAsync();
                }

                if (isNew)
                {
                    sd.Qty = pickQty;
                    sd.LockQty = pickQty;
                }
                else
                {
                    if (palletNo != palletNoNew)
                    {
                        //修改拼托托盘库存明细
                        pinStockDetail.Qty += pickQty;
                        pinStockDetail.LockQty += pickQty;
                        await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
                    }
                }

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货拼托", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的原托盘码为：{palletNo}，新托盘码为：{palletNoNew}的拣货拼托操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }
        /// <summary>
        /// 拼托出库pda拣货-数量
        /// </summary>
        /// <param name="soNo"></param>
        /// <param name="soDetailId"></param>
        /// <param name="palletNo"></param>
        /// <param name="PickQty"></param>
        /// <param name="palletNoNew"></param>
        /// <param name="userId"></param>
        public async Task SoSetQtyPinPick(string soNo, string soDetailId, string palletNo, string PickQty, string palletNoNew, int userId)
        {
            Db.BeginTran();
            try
            {
                var nowDate = DateTime.Now;//当前时间
                #region 判断

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw Oops.Bah("出库单据不能为空");
                }
                //if (string.IsNullOrWhiteSpace(soDetailId))
                //{
                //    throw new Exception("出库物料-批次不能为空");
                //}
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘码不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNoNew))
                {
                    throw Oops.Bah("新托盘码不能为空");
                }

                //出库单
                var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
                    .FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw Oops.Bah("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
                    m.IsDel == "0" && (m.Status == "2" || m.Status == "3") && m.SONo == soNo &&
                    m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
                if (allot == null)
                {
                    throw Oops.Bah("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;
                if (int.Parse(PickQty) > needQty)
                {
                    throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
                }

                //库存明细
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询到该托盘分配的库存信息！");
                }
                if (palletNo == palletNoNew)//原托盘与新托盘一致
                {
                    if (int.Parse(PickQty) != stockDetail.Qty)
                    {
                        throw Oops.Bah("原托盘与新托盘一致，需要把托盘上所有数量拣货");
                    }
                }
                #endregion

                #region 拼托信息
                bool isNew = false;
                var pinStockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew);
                if (pinStockDetail != null)
                {
                    if (palletNo != palletNoNew)//非整托拣货
                    {
                        if (pinStockDetail.SONo != notice.SONo)
                        {
                            throw Oops.Bah("拼托托盘上只能放同一个出库单下的物料！");
                        }
                        if (pinStockDetail.SkuName != stockDetail.SkuName || pinStockDetail.LotNo != stockDetail.LotNo)
                        {
                            isNew = true;
                        }
                    }
                }
                else
                {
                    isNew = true;

                    var newPalletInfo = await Db.Queryable<SysPallets>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
                    if (newPalletInfo == null)
                    {
                        throw Oops.Bah("新托盘信息不存在或已被使用！");
                    }
                    //修改新托盘状态
                    newPalletInfo.Status = "1";
                    await Db.Updateable(newPalletInfo).ExecuteCommandAsync();
                }

                if (isNew)
                {
                    var sd = new DataStockDetail();

                    sd.LotNo = stockDetail.LotNo;
                    sd.LotText = stockDetail.LotText;
                    sd.SupplierLot = stockDetail.SupplierLot;
                    sd.SkuNo = stockDetail.SkuNo;
                    sd.SkuName = stockDetail.SkuName;
                    sd.Standard = stockDetail.Standard;

                    sd.Qty = int.Parse(PickQty);
                    sd.LockQty = int.Parse(PickQty);

                    sd.FrozenQty = 0;
                    sd.InspectQty = 0;
                    sd.ASNNo = "";
                    sd.ASNDetailNo = null;
                    sd.SONo = soNo;//出库单号
                    sd.WareHouseNo = "";
                    sd.RoadwayNo = "";
                    sd.AreaNo = "";
                    sd.LocatNo = "";
                    sd.PalletNo = palletNoNew;
                    sd.PalletNo2 = "";
                    sd.PalletNo3 = "";
                    //PalletType = item.PalletType,
                    sd.CompleteTime = nowDate;
                    sd.ProductionTime = stockDetail.ProductionTime;
                    sd.ExpirationTime = stockDetail.ExpirationTime;
                    sd.Status = "2";//状态，已分配
                    sd.InspectMark = stockDetail.InspectMark;
                    sd.InspectStatus = stockDetail.InspectStatus;
                    sd.BitPalletMark = "0";
                    sd.PackagNo = noticeDetail.PackagNo;
                    sd.IsBale = stockDetail.IsBale;
                    sd.IsBelt = stockDetail.IsBelt;
                    sd.Demo = stockDetail.Demo;
                    sd.OwnerName = stockDetail.OwnerName;
                    sd.OwnerNo = stockDetail.OwnerNo;
                    sd.SupplierName = stockDetail.SupplierName;
                    sd.SupplierNo = stockDetail.SupplierNo;

                    sd.IsDel = "0";
                    sd.CreateUser = userId;
                    sd.CreateTime = nowDate;

                    //新增拼托库存明细信息
                    await Db.Insertable(sd).ExecuteReturnIdentityAsync();
                }
                else
                {
                    if (palletNo != palletNoNew)
                    {
                        //修改拼托托盘库存明细
                        pinStockDetail.Qty += int.Parse(PickQty);
                        pinStockDetail.LockQty += int.Parse(PickQty);
                        await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        pinStockDetail.SONo = soNo;
                        await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
                    }
                }
                #endregion

                //获取当前托盘拣货明细
                var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

                //判读是否存在拣货明细
                int isComplete = 0;
                if (complete != null)
                {
                    isComplete = 1;
                }

                var comList = new List<BllCompleteDetail>();
                //判断是否存在拣货明细
                isComplete = 0;//所有无箱码或一级箱码拣货时，拣货明细应重新插入数据(体现多次拣货流程记录)
                if (isComplete == 0)
                {
                    //添加拣货明细
                    var completeDetail = new BllCompleteDetail()
                    {
                        SONo = soNo,
                        SODetailNo = int.Parse(soDetailId),
                        ExportAllotId = allot.Id,
                        StockId = allot.StockId,
                        BoxNo = "",
                        BoxNo2 = "",
                        BoxNo3 = "",

                        LotNo = allot.LotNo,
                        LotText = allot.LotText,
                        SupplierLot = allot.SupplierLot,
                        SkuNo = allot.SkuNo,
                        SkuName = allot.SkuName,
                        Standard = allot.Standard,
                        PalletNo = palletNo,
                        CompleteQty = int.Parse(PickQty),

                        CreateUser = userId,
                        CreateTime = Db.GetDate(),
                    };
                    comList.Add(completeDetail);

                    //添加拣货明细
                    await Db.Insertable(comList).ExecuteCommandAsync();
                }
                else if (isComplete == 1)
                {
                    complete.CompleteQty += int.Parse(PickQty);
                    complete.UpdateUser = userId;
                    complete.UpdateTime = Db.GetDate();

                    await Db.Updateable(complete).ExecuteCommandAsync();
                }

                //修改出库分配信息
                allot.CompleteQty += int.Parse(PickQty);
                allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
                allot.UpdateTime = DateTime.Now;
                await Db.Updateable(allot).ExecuteCommandAsync();

                int isDel = 0;

                if (palletNo != palletNoNew)
                {
                    //删除或修改库存明细
                    stockDetail.BitPalletMark = "1";//修改为零托标识
                    stockDetail.Qty -= int.Parse(PickQty);
                    stockDetail.LockQty -= int.Parse(PickQty);
                    if (stockDetail.Qty == stockDetail.LockQty)
                    {
                        stockDetail.Status = "2";
                    }
                    else if (stockDetail.Qty > stockDetail.LockQty && stockDetail.LockQty > 0)
                    {
                        stockDetail.Status = "1";
                    }
                    else
                    {
                        stockDetail.Status = "0";
                    }
                    if (stockDetail.Qty <= 0)
                    {
                        await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                    }
                    else
                    {
                        isDel = 1;
                        await Db.Updateable(stockDetail).ExecuteCommandAsync();
                    }
                }
                else
                {
                    isDel = 1;
                }
                //判断托盘上物料是否拣货完毕
                if (isDel == 0)
                {
                    //改变托盘状态为：未使用
                    var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
                    if (pallet == null)
                    {
                        throw Oops.Bah("未在托盘表中查询到托盘信息");
                    }

                    pallet.Status = "0";
                    await Db.Updateable(pallet).ExecuteCommandAsync();
                }

                //修改出库单明细拣货数量
                noticeDetail.CompleteQty += int.Parse(PickQty);
                await Db.Updateable(noticeDetail).ExecuteCommandAsync();

                var num = await Db.Queryable<BllExportNoticeDetail>()
                    .CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                if (num <= 0)
                {
                    notice.Status = "4"; //更改为执行完成
                }
                //修改出库单信息
                await Db.Updateable(notice).ExecuteCommandAsync();

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货拼托", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}，新托盘码为：{palletNoNew}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }
        #endregion

        #region JC23版取样

        //根据托盘号获取取样类型
        public async Task<string> GetSampleType2(string palletNo)
        {
            var type = "";
            var detail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
            if (detail == null)
            {
                throw Oops.Bah("当前托盘未在库存中");
            }

            var boxInfo = await Db.Queryable<DataBoxInfo>().CountAsync(m => m.IsDel == "0" && m.StockDetailId == detail.Id);

            //判断托盘上是否有箱码信息
            if (boxInfo > 0)
            {
                type = "0";//标签取样
            }
            else
            {
                type = "1";//数量取样
            }
            return type;
        }

        //获取待出库或待取样的请验单
        public async Task<List<string>> GetInspectionNo()
        {
            return await Db.Queryable<BllQualityInspectionRequest>().Where(m => m.IsDel == "0" && (m.Status == "1" || m.Status == "2")).OrderByDescending(m => m.QcNo).Select(m => m.QcNo).ToListAsync();
        }

        //获取请验单相关信息
        public async Task<InspectionRequestDto> GetInspectionRequestInfo(string qcNo)
        {
            var data = new InspectionRequestDto();
            var inspectionRequest = await Db.Queryable<BllQualityInspectionRequest>().FirstAsync(m => m.IsDel == "0" && m.QcNo == qcNo);
            var samplingQty = await Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).SumAsync(m => m.CompleteQty);

            data.QcNo = qcNo;
            data.Sku = inspectionRequest.SkuNo + "-" + inspectionRequest.SkuName;
            data.LotNo = inspectionRequest.LotNo;
            data.Qty = inspectionRequest.SamplingQty.ToString();
            data.SamplingQty = samplingQty == null ? "0" : samplingQty.ToString();

            return data;
        }

        //取样出库拣货(标签)
        public async Task SampleSetPick(string qcNo, string palletNo, string boxNo, string boxNo3, string pickQty, int userId)
        {
            try
            {
                #region 判断

                if (string.IsNullOrWhiteSpace(qcNo))
                {
                    throw Oops.Bah("请验单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘号不能为空");
                }
                var type = await GetSampleType2(palletNo);
                if (type != "0")
                {
                    throw Oops.Bah("当前托盘请在数量页签取样");
                }
                if (string.IsNullOrEmpty(boxNo))
                {
                    throw Oops.Bah("外箱条码不能为空");
                }
                //if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty) && int.Parse(pickQty) > 0)
                //{
                //    throw new Exception("追溯条码和拣货数量不能同时输入");
                //}

                //请验单
                var inspecd = await Db.Queryable<BllQualityInspectionRequest>().FirstAsync(m => m.IsDel == "0" && m.QcNo == qcNo);
                if (inspecd == null)
                {
                    throw Oops.Bah("未查询到请验单信息");
                }
                if (inspecd.Status == "0" || inspecd.Status == "3")
                {
                    throw Oops.Bah("请验单状态错误，请核实");
                }
                //库存明细信息
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未在库存中查询出当前托盘信息");
                }
                if (!string.IsNullOrWhiteSpace(stockDetail.LocatNo))
                {
                    throw Oops.Bah("当前托盘不是库外托盘，请核实");
                }
                //箱支信息 
                var boxInfoList = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo).ToListAsync();
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询出库存总信息");
                }
                //入库单
                var notice = await Db.Queryable<BllArrivalNotice>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到入库单信息");
                }

                #endregion

                //取样明细记录表
                var sampld = await Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).ToListAsync();

                var isAddSampld = false;
                var PickType = ""; //0数量拣货  1 箱支拣货
                var EditboxInfo = new DataBoxInfo();
                var EditboxInfoList = new List<DataBoxInfo>();

                #region 判断拣货方式 散支 数量

                if (!string.IsNullOrEmpty(pickQty) && decimal.Parse(pickQty) > 0) //数量拣货
                {
                    PickType = "0";

                    if (!string.IsNullOrWhiteSpace(boxNo3)) //支中拣数量
                    {
                        if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) == 0)
                        {
                            throw Oops.Bah("未查询到支码信息");
                        }
                        if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) > 1)
                        {
                            throw Oops.Bah("支码信息数据信息错误，请核实");
                        }
                        EditboxInfo = await Db.Queryable<DataBoxInfo>().FirstAsync(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo && m.BoxNo3 == boxNo3);
                        if (EditboxInfo.Qty < decimal.Parse(pickQty))
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }
                        isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo && m.BoxNo3 == EditboxInfo.BoxNo3) == 0;
                    }
                    else //箱中拣数量
                    {

                        if (boxInfoList.Count == 0)
                        {
                            throw Oops.Bah("未在托盘上查询到箱码信息，请核实");
                        }
                        if (boxInfoList.Count > 1)
                        {
                            throw Oops.Bah("箱码数据信息错误，请核实");
                        }
                        if (boxInfoList.Count(m => !string.IsNullOrWhiteSpace(m.BoxNo3)) > 0)
                        {
                            throw Oops.Bah("当前箱码中含有支码，请输入支码信息取样");
                        }
                        EditboxInfo = await Db.Queryable<DataBoxInfo>().FirstAsync(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo);

                        if (EditboxInfo.Qty < decimal.Parse(pickQty))
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }
                        isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo) == 0;

                    }
                    if (sampld.Sum(m => m.CompleteQty) + decimal.Parse(pickQty) > inspecd.SamplingQty)
                    {
                        throw Oops.Bah("取样总拣货数量大于请验单取样数量");
                    }
                    //判断箱中是否含有支码，有：不让拣数量
                    if (stockDetail.Qty - stockDetail.LockQty - stockDetail.FrozenQty < decimal.Parse(pickQty))
                    {
                        throw Oops.Bah("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
                    }
                }
                else //箱支拣货
                {
                    PickType = "1";
                    var qty = 0m;

                    if (!string.IsNullOrWhiteSpace(boxNo3)) //拣支
                    {

                        if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) == 0)
                        {
                            throw Oops.Bah("未查询到支码信息");
                        }
                        if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) > 1)
                        {
                            throw Oops.Bah("支码数据信息错误，请核实");
                        }
                        EditboxInfoList = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo && m.BoxNo3 == boxNo3).ToListAsync();
                        if (EditboxInfoList.Sum(m => m.Qty) + sampld.Sum(m => m.CompleteQty) > inspecd.SamplingQty)
                        {
                            throw Oops.Bah("取样总拣货数量大于请验单取样数量");
                        }
                        qty = EditboxInfoList.Sum(m => m.Qty);
                        //isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo && m.BoxNo3 == EditboxInfo.BoxNo3) == 0;
                    }
                    else //拣箱
                    {

                        if (boxInfoList.Count == 0)
                        {
                            throw Oops.Bah("未在托盘上查询到箱码信息，请核实");
                        }
                        if (boxInfoList.Count > 1)
                        {
                            throw Oops.Bah("箱码数据信息错误，请核实");
                        }
                        if (boxInfoList.Count(m => !string.IsNullOrWhiteSpace(m.BoxNo3)) > 0)
                        {
                            throw Oops.Bah("当前箱码中含有支码，请输入支码信息取样");
                        }
                        EditboxInfoList = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo).ToListAsync();

                        if (EditboxInfo.Qty < decimal.Parse(pickQty))
                        {
                            throw Oops.Bah("拣货数量不能大于箱内数量");
                        }
                        qty = EditboxInfoList.Sum(m => m.Qty);
                        //isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo) == 0;
                    }
                    if (sampld.Sum(m => m.CompleteQty) + qty > inspecd.SamplingQty)
                    {
                        throw Oops.Bah("取样总拣货数量大于请验单取样数量");
                    }
                    if (stockDetail.Qty - stockDetail.LockQty - stockDetail.FrozenQty < qty)
                    {
                        throw Oops.Bah("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
                    }
                }
                #endregion

                Db.BeginTran();
                #region 


                if (PickType == "0")
                {

                    #region 添加或修改取样明细

                    var boxInfo = EditboxInfo;

                    //if (isAddSampld) //添加取样明细
                    //{
                    var sampleDetail = new BllSamplingDetails()
                    {
                        QcNo = qcNo,
                        ASNNo = inspecd.ASNNo,
                        PalletNo = palletNo,
                        BoxNo = boxInfo.BoxNo,
                        BoxNo2 = boxInfo.BoxNo2,
                        BoxNo3 = boxInfo.BoxNo3,
                        SkuNo = boxInfo.SkuNo,
                        SkuName = boxInfo.SkuName,
                        Standard = boxInfo.Standard,
                        LotNo = boxInfo.LotNo,
                        SupplierLot = boxInfo.SupplierLot,
                        CompleteQty = decimal.Parse(pickQty),
                        CreateTime = DateTime.Now,
                        CreateUser = userId
                    };
                    Db.Insertable(sampleDetail).ExecuteCommand();
                    //}
                    //else
                    //{
                    //    var sampldFirst = sampld.First(m => m.PalletNo == palletNo && m.BoxNo == boxInfo.BoxNo);
                    //    if (!string.IsNullOrWhiteSpace(boxNo3))
                    //    {
                    //        sampldFirst = sampld.First(m => m.PalletNo == palletNo && m.BoxNo == boxInfo.BoxNo && m.BoxNo3 == boxInfo.BoxNo3);
                    //    }
                    //    sampldFirst.CompleteQty += decimal.Parse(pickQty);
                    //    sampldFirst.UpdateTime = DateTime.Now;
                    //    sampldFirst.UpdateUser = userId;
                    //    Db.Updateable(sampldFirst).ExecuteCommand();
                    //}

                    #endregion

                    #region 修改库存三表

                    //拆包有效期更改
                    var unpackWarranty = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo).UnpackWarranty;
                    foreach (var item in boxInfoList)
                    {
                        item.BitBoxMark = "1";
                        item.InspectMark = "1";

                        if (unpackWarranty > 0 && boxInfoList.Count(m => m.ProductionTime != null) > 0)
                        {
                            if (item.ProductionTime != null)
                            {
                                var time = DateTime.Parse(item.ProductionTime.ToString()).AddDays((double)unpackWarranty);
                                if (time < item.ExpirationTime)
                                {
                                    item.ExpirationTime = time;
                                }
                            }
                        }

                    }
                    Db.Updateable(boxInfoList).ExecuteCommand();

                    //库存箱码
                    boxInfo.Qty -= decimal.Parse(pickQty);
                    if (boxInfo.Qty == 0)
                    {
                        Db.Deleteable(boxInfo).ExecuteCommand();
                    }
                    else
                    {
                        Db.Updateable(boxInfo).ExecuteCommand();
                    }
                    //库存明细
                    stockDetail.Qty -= decimal.Parse(pickQty);
                    if (stockDetail.Qty == 0)
                    {
                        Db.Deleteable(stockDetail).ExecuteCommand();
                    }
                    else
                    {
                        Db.Updateable(stockDetail).ExecuteCommand();
                    }
                    //库存总表
                    stock.Qty -= decimal.Parse(pickQty);
                    if (stock.Qty == 0)
                    {
                        Db.Deleteable(stock).ExecuteCommand();
                    }
                    else
                    {
                        Db.Updateable(stock).ExecuteCommand();
                    }

                    #endregion

                    #region 修改入库单

                    //不是上传完毕的修改取样状态
                    if (notice.Status != "4")
                    {
                        var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                        if (noticeDetail.IsSampling == "0")
                        {
                            noticeDetail.IsSampling = "1";

                            Db.Updateable(noticeDetail).ExecuteCommand();
                        }

                    }


                    #endregion

                    #region 修改请验单

                    inspecd.Status = "2";
                    inspecd.UpdateTime = DateTime.Now;
                    if (sampld.Sum(m => m.CompleteQty) + decimal.Parse(pickQty) >= inspecd.SamplingQty)
                    {
                        inspecd.Status = "3";
                    }
                    Db.Updateable(inspecd).ExecuteCommand();
                    #endregion

                }
                else
                {
                    var sumQty = 0m;
                    foreach (var boxInfo in EditboxInfoList)
                    {
                        #region 添加或修改取样明细

                        //if (isAddSampld) //添加取样明细
                        //{
                        var sampleDetail = new BllSamplingDetails()
                        {
                            QcNo = qcNo,
                            ASNNo = inspecd.ASNNo,
                            PalletNo = palletNo,
                            BoxNo = boxInfo.BoxNo,
                            BoxNo2 = boxInfo.BoxNo2,
                            BoxNo3 = boxInfo.BoxNo3,
                            SkuNo = boxInfo.SkuNo,
                            SkuName = boxInfo.SkuName,
                            Standard = boxInfo.Standard,
                            LotNo = boxInfo.LotNo,
                            SupplierLot = boxInfo.SupplierLot,
                            CompleteQty = boxInfo.Qty,
                            CreateTime = DateTime.Now,
                            CreateUser = userId
                        };
                        await Db.Insertable(sampleDetail).ExecuteCommandAsync();
                        //}
                        //else
                        //{
                        //    var sampldFirst = sampld.First(m => m.PalletNo == palletNo && m.BoxNo == boxInfo.BoxNo);
                        //    if (!string.IsNullOrWhiteSpace(boxNo3))
                        //    {
                        //        sampldFirst = sampld.First(m => m.PalletNo == palletNo && m.BoxNo == boxInfo.BoxNo && m.BoxNo3 == boxInfo.BoxNo3);
                        //    }
                        //    sampldFirst.CompleteQty += boxInfo.Qty;
                        //    sampldFirst.UpdateTime = DateTime.Now;
                        //    sampldFirst.UpdateUser = userId;
                        //    Db.Updateable(sampldFirst).ExecuteCommand();
                        //}
                        #endregion

                        #region 修改库存三表

                        //拆包有效期更改
                        var unpackWarranty = (await Db.Queryable<SysMaterials>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo)).UnpackWarranty;

                        foreach (var item in boxInfoList)
                        {
                            item.BitBoxMark = "1";
                            item.InspectMark = "1";
                            if (unpackWarranty > 0 && boxInfoList.Count(m => m.ProductionTime != null) > 0)
                            {
                                if (item.ProductionTime != null)
                                {
                                    var time = DateTime.Parse(item.ProductionTime.ToString()).AddDays((double)unpackWarranty);
                                    if (time < item.ExpirationTime)
                                    {
                                        item.ExpirationTime = time;
                                    }
                                }
                            }
                        }
                        await Db.Updateable(boxInfoList).ExecuteCommandAsync();

                        //库存箱码

                        await Db.Deleteable(boxInfo).ExecuteCommandAsync();

                        //库存明细
                        stockDetail.Qty -= boxInfo.Qty;
                        if (stockDetail.Qty == 0)
                        {
                            await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                        }
                        else
                        {
                            await Db.Updateable(stockDetail).ExecuteCommandAsync();
                        }
                        //库存总表
                        stock.Qty -= boxInfo.Qty;
                        if (stock.Qty == 0)
                        {
                            await Db.Deleteable(stock).ExecuteCommandAsync();
                        }
                        else
                        {
                            await Db.Updateable(stock).ExecuteCommandAsync();
                        }

                        #endregion

                        #region 修改入库单

                        //不是上传完毕的修改取样状态
                        if (notice.Status != "4")
                        {
                            var noticeDetail = await Db.Queryable<BllArrivalNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                            if (noticeDetail.IsSampling == "0")
                            {
                                noticeDetail.IsSampling = "1";

                                await Db.Updateable(noticeDetail).ExecuteCommandAsync();
                            }

                        }

                        #endregion

                        sumQty += boxInfo.Qty;
                    }

                    #region 修改请验单
                    inspecd.Status = "2";
                    inspecd.UpdateTime = DateTime.Now;
                    if (sampld.Sum(m => m.CompleteQty) + sumQty >= inspecd.SamplingQty)
                    {
                        inspecd.Status = "3";
                    }

                    await Db.Updateable(inspecd).ExecuteCommandAsync();
                    #endregion
                }

                #endregion


                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "取样拣货", qcNo, "拣货", $"在PDA上对请验单号为：{qcNo}的托盘码为：{palletNo}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }


        //取样出库拣货(数量)
        public async Task SampleSetQtyPick(string qcNo, string palletNo, string pickQty, int userId)
        {
            try
            {
                #region 判断

                if (string.IsNullOrWhiteSpace(qcNo))
                {
                    throw Oops.Bah("请验单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw Oops.Bah("托盘号不能为空");
                }
                var type = await GetSampleType2(palletNo);
                if (type != "1")
                {
                    throw Oops.Bah("当前托盘请在标签页签取样");
                }
                if (string.IsNullOrWhiteSpace(pickQty))
                {
                    throw Oops.Bah("拣货数量不能为空");
                }
                if (decimal.Parse(pickQty) <= 0)
                {
                    throw Oops.Bah("拣货数量不能小于等于0");
                }

                //请验单
                var inspecd = await Db.Queryable<BllQualityInspectionRequest>().FirstAsync(m => m.IsDel == "0" && m.QcNo == qcNo);
                if (inspecd == null)
                {
                    throw Oops.Bah("未查询到请验单信息");
                }
                if (inspecd.Status == "0" || inspecd.Status == "3")
                {
                    throw Oops.Bah("请验单状态错误，请核实");
                }
                //库存明细信息
                var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo 
                && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                if (stockDetail == null)
                {
                    throw Oops.Bah("未在库存中查询出当前托盘信息");
                }
                // 判断托盘是否在库内
                if (!string.IsNullOrWhiteSpace(stockDetail.LocatNo))
                {
                    var wareHouseData = await Db.Queryable<SysWareHouse>().FirstAsync(m => m.IsDel == "0" && m.WareHouseNo == stockDetail.WareHouseNo);
                    if (wareHouseData.Type != "2") 
                    {
                        throw Oops.Bah("当前托盘不是库外托盘，请核实");
                    }
                }
                //库存总表
                var stock = await Db.Queryable<DataStock>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                if (stock == null)
                {
                    throw Oops.Bah("未查询出库存总信息");
                }
                //入库单
                var notice = await Db.Queryable<BllArrivalNotice>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo);
                if (notice == null)
                {
                    throw Oops.Bah("未查询到入库单信息");
                }

                #endregion

                //取样明细记录表
                var sampld = await Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).ToListAsync();
                var qty = decimal.Parse(pickQty);
                //var isAddSampld = sampld.Count(m => m.PalletNo == palletNo) == 0; 


                #region 判断数量

                if (sampld.Sum(m => m.CompleteQty) + qty > inspecd.SamplingQty)
                {
                    throw Oops.Bah("取样总拣货数量大于请验单取样数量");
                }
                //判断箱中是否含有支码，有：不让拣数量
                if (stockDetail.Qty - stockDetail.LockQty - stockDetail.FrozenQty < qty)
                {
                    throw Oops.Bah("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
                }


                #endregion

                #region 添加或修改取样明细

                Db.BeginTran();

                //if (isAddSampld) //添加取样明细
                //{
                var sampleDetail = new BllSamplingDetails()
                {
                    QcNo = qcNo,
                    ASNNo = inspecd.ASNNo,
                    PalletNo = palletNo,
                    SkuNo = stockDetail.SkuNo,
                    SkuName = stockDetail.SkuName,
                    Standard = stockDetail.Standard,
                    LotNo = stockDetail.LotNo,
                    SupplierLot = stockDetail.SupplierLot,
                    CompleteQty = qty,
                    CreateTime = DateTime.Now,
                    CreateUser = userId
                };
                await Db.Insertable(sampleDetail).ExecuteCommandAsync();
                //}
                //else
                //{
                //    var sampldFirst = sampld.First(m => m.PalletNo == palletNo);
                //    sampldFirst.CompleteQty += qty;
                //    sampldFirst.UpdateTime = DateTime.Now;
                //    sampldFirst.UpdateUser = userId;
                //    Db.Updateable(sampldFirst).ExecuteCommand();
                //}

                #endregion

                #region 修改库存三表

                //库存明细
                stockDetail.Qty -= qty;
                if (stockDetail.Qty == 0)
                {
                    await Db.Deleteable(stockDetail).ExecuteCommandAsync();
                }
                else
                {
                    stockDetail.BitPalletMark = "1";
                    stockDetail.InspectMark = "1";

                    await Db.Updateable(stockDetail).ExecuteCommandAsync();
                }
                //库存总表
                stock.Qty -= qty;
                if (stock.Qty == 0)
                {
                    await Db.Deleteable(stock).ExecuteCommandAsync();
                }
                else
                {
                    await Db.Updateable(stock).ExecuteCommandAsync();
                }

                #endregion

                #region 修改入库单

                //不是上传完毕的修改取样状态
                if (notice.Status != "4")
                {
                    var noticeDetail = await Db.Queryable<BllArrivalNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
                    if (noticeDetail.IsSampling == "0")
                    {
                        noticeDetail.IsSampling = "1";

                        await Db.Updateable(noticeDetail).ExecuteCommandAsync();
                    }

                }


                #endregion

                #region 修改请验单
                inspecd.Status = "2";
                inspecd.UpdateTime = DateTime.Now;
                if (sampld.Sum(m => m.CompleteQty) + qty >= inspecd.SamplingQty)
                {
                    inspecd.Status = "3";
                }
                await Db.Updateable(inspecd).ExecuteCommandAsync();
                #endregion

                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("PDA模块", "取样拣货", qcNo, "拣货", $"在PDA上对请验单号为：{qcNo}的托盘码为：{palletNo}的拣货操作", userId);
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw e;
            }
        }

        #endregion

    }
}