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;

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

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

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

                return sqlMsg;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        //获取托盘中含有的执行中的单据
        public List<string> GetRunSoNoticeList(string palletNo, string type)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(palletNo))//判断托盘是否为空
                {
                    throw new Exception("托盘码为空，请输入托盘码");
                }
                if (type == "1")//平库出库获取单据
                {
                    var allotList = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.Status == "1" && m.PalletNo == palletNo).Select(m => m.SONo).Distinct().Where(m => !string.IsNullOrWhiteSpace(m)).ToList();
                    return allotList;
                }
                //获取状态为待拣货或者部分拣货的出库单
                var allotList2 = 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)).ToList();

                //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;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        //获取出库托盘上的物料批次(根据托盘码)
        public List<DetailIdSkuLotNo> GetSoSkuLotNoListByPallet(string palletNo, string soNo)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(palletNo))//判断托盘是否为空
                {
                    throw new Exception("托盘码为空，请输入托盘码");
                }
                //获取状态为待拣货或者部分拣货的出库单
                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 = 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,
                }).ToList();

                return list;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        //获取出库口、规格、待拣及已拣数量（根据出库单明细ID、托盘号）
        public OutPdaInfo GetOutlets(string soDetailId, string palletNo)
        {
            try
            {

                var allotInfo = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo && (m.Status == "2" || m.Status == "3")).ToList();
                if (allotInfo.Count == 0)
                {
                    throw new Exception($"{palletNo}托盘上未查询到分配信息，请核实");
                }
                if (allotInfo.Count > 1)
                {
                    throw new Exception($"{palletNo}托盘上存在多条相同的分配信息，请核实");
                }
                var data = allotInfo.First();
                var data2 = new OutPdaInfo()
                {
                    OutModel = data.OutMode,
                    Standard = data.Standard,
                    PickQty = data.Qty,
                    PickedQty = data.CompleteQty
                };
                return data2;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

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

        //获取箱码信息（根据箱码在库存箱码明细中查询及拣货明细中拣货数量）
        public List<BoxInfo> GetDataComBoxInfo(string soDetailId, string palletNo, string boxNo, string boxNo3)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw new Exception("托盘号不能为空");
                }
                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 new Exception("未在库存中查询到信息");
                }

                var type = "0";//0：查箱码或支码不分组 1：查托盘分组 显示箱
                var list = new List<BoxInfo>();
                if (!string.IsNullOrWhiteSpace(boxNo3) || !string.IsNullOrWhiteSpace(boxNo))//判断支码是否为空
                {
                    foreach (var demo in info.ToList())
                    {
                        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 = info.GroupBy(m => new { m.BoxNo }).Select(it => new BoxInfo
                    {
                        BoxNo = it.BoxNo,
                        Qty = SqlFunc.AggregateSum(it.Qty)
                    }).ToList();
                    type = "1";
                }
                if (!string.IsNullOrWhiteSpace(soDetailId))
                {
                    var allotInfos = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo && (m.Status == "2" || m.Status == "3")).ToList();
                    if (allotInfos.Count == 0)
                    {
                        throw new Exception($"{palletNo}托盘上未查询到分配信息，请核实");
                    }
                    if (allotInfos.Count > 1)
                    {
                        throw new Exception($"{palletNo}托盘上存在多条相同的分配信息，请核实");
                    }
                    var allotInfo = allotInfos.First();
                    var comInfo = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allotInfo.Id).ToList();
                    if (comInfo.Count != 0)
                    {
                        if (type == "0")
                        {
                            foreach (var demo in list)
                            {
                                var com = comInfo.FirstOrDefault(m => m.IsDel == "0" && 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;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }



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

                if (string.IsNullOrWhiteSpace(soNo))
                {
                    throw new Exception("出库单据不能为空");
                }
                if (string.IsNullOrWhiteSpace(soDetailId))
                {
                    throw new Exception("出库物料-批次不能为空");
                }
                if (string.IsNullOrWhiteSpace(palletNo))
                {
                    throw new Exception("托盘码不能为空");
                }
                
                //出库单
                var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
                if (notice == null)
                {
                    throw new Exception("未查询到该出库单的信息");
                }
                if (notice.Status != "3")
                {
                    throw new Exception("出库单的状态不是正在执行，不能拣货");
                }
                //出库单明细
                var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
                    .First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
                if (noticeDetail == null)
                {
                    throw new Exception("未查询到该出库单明细的信息");
                }
                //出库分配信息
                var allot = Db.Queryable<BllExportAllot>().First(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 new Exception("未查询到该托盘的分配信息");
                }
                //剩余拣货数量（待拣减去已拣）
                var needQty = allot.Qty - allot.CompleteQty;

                //库存明细
                var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
                if (stockDetail == null)
                {
                    throw new Exception("未查询到该托盘分配的库存明细信息！");
                }
                //库存总表
                var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw new Exception("未查询到该托盘分配的库存信息！");
                }
                #endregion
                if (string.IsNullOrWhiteSpace(boxNo))//整托拣货
                {
                    List<DataBoxInfo> boxInfos;
                    var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo);//找到托盘上所有箱码
                    boxInfos = boxInfo.ToList();
                    if (boxInfo.Count() <= 0)
                    {
                        throw new Exception("该托盘上没有可拣货的箱子");
                    }
                    var boxQty = boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
                    if (boxQty[0] > needQty)
                    {
                        throw new Exception("拣货数量不能大于箱内剩余待拣数量");
                    }
                    var pickQty = 0;//拣货的数量
                    var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        if (comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
                        {
                            throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
                        }
                        if (item.SkuNo != allot.SkuNo || item.LotNo != allot.LotNo)
                        {
                            throw new Exception("当前托盘上有其他不同物料批次，拣货失败");
                        }
                        //添加拣货明细
                        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);

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

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

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

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

                        biaoShi = "1";
                    }
                    else //整箱拣货
                    {
                        if (boxInfo.Count() == 0)
                        {
                            throw new Exception("未查询到该箱码的信息");
                        }
                        if (boxInfo.Any(m => m.PalletNo != palletNo))
                        {
                            throw new Exception("该托盘与箱码没有绑定关系");
                        }
                        var boxQty = boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
                        if (boxQty[0] > needQty)
                        {
                            throw new Exception("拣货数量不能大于箱内剩余待拣数量");
                        }
                    }
                    var pickQty = 0;//拣货的数量
                    var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
                    var comList = new List<BllCompleteDetail>();
                    foreach (var item in boxInfos)
                    {
                        if (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 = item.Qty,

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

                        //删除库存箱码明细
                        Db.Deleteable(item).ExecuteCommand();
                        pickQty += item.Qty;
                    }
                    //改变库内箱码是否零箱信息
                    if (biaoShi == "1")
                    {
                        var boxSurplusList = boxInfo.Where(m => m.BoxNo3 != boxNo3).ToList();
                        foreach (var item in boxSurplusList)
                        {
                            item.BitBoxMark = "1";
                            Db.Updateable(item).ExecuteCommand();
                        }
                    }

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

                    //删除或修改库存明细
                    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)
                    {
                        Db.Deleteable(stockDetail).ExecuteCommand();
                    }
                    else
                    {
                        Db.Updateable(stockDetail).ExecuteCommand();
                    }
                    stock.Qty -= pickQty;
                    stock.LockQty -= pickQty;
                    if (stock.Qty <= 0)
                    {
                        Db.Deleteable(stock).ExecuteCommand();
                    }
                    else
                    {
                        Db.Updateable(stock).ExecuteCommand();
                    }
                    var num2 = Db.Queryable<DataStockDetail>().Count(m => m.IsDel == "0" && m.PalletNo == palletNo);
                    if (num2 <= 0)
                    {
                        //改变托盘状态
                        var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
                        if (pallet == null)
                        {
                            throw new Exception("未在托盘表中查询到托盘信息");
                        }
                        pallet.Status = "0";
                        Db.Updateable(pallet).ExecuteCommand();
                    }
                    //修改出库单明细拣货数量
                    noticeDetail.CompleteQty += pickQty;
                    Db.Updateable(noticeDetail).ExecuteCommand();

                    var num = Db.Queryable<BllExportNoticeDetail>()
                        .Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
                    if (num <= 0)
                    {
                        notice.Status = "4"; //更改为执行完成
                    }
                    //修改出库单信息
                    Db.Updateable(notice).ExecuteCommand();
                }
                Db.CommitTran();
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 下发空托出库
        /// </summary>
        /// <param name="model"> </param>
        /// <param name="userId"> </param>
        /// <param name="url"> </param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public string IssuePlnOutHouse(OutModePalletVm model, int userId,string url)
        {
            try
            {
                string strMsg = "";
                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);
                if (stockDetail.Count > 0)
                {
                    //判断是否大于需要垛数
                    if (stockDetail.Count< int.Parse(model.Num))
                    {
                        strMsg = "需要垛数大于库存垛数，请重新输入!";
                        return strMsg;
                    }
                }
                //获取库存总表信息
                var stock = Db.Queryable<DataStock>().First(s => s.IsDel == "0" && s.SkuNo == "100099");
                //验证库存总表是否为空
                if (stock == null)
                {
                    strMsg = "库存信息不存在，请核查!";
                    return strMsg;
                }

                int i = 0;

                Db.BeginTran();

                //遍历库存信息 
                foreach (var s in stockDetail)
                {
                    //获取储位信息
                    var locat = Db.Queryable<SysStorageLocat>().First(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; //修改人
                        //修改储位信息
                        Db.Updateable(locat).ExecuteCommand();
                    }

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

                    //增加库存明细锁定数量
                    //s.AllotQty += 
                    s.LockQty += (int)s.Qty; //锁定数量
                    s.UpdateTime = serverTime; //修改时间
                    s.UpdateUser = userId; //修改人
                    s.Status = "2"; //2 已分配
                    //修改库存明细信息
                    Db.Updateable(s).ExecuteCommand();
                    
                    #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
                    };
                    Db.Insertable(allot).ExecuteCommand();

                    #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
                    });
                    Db.Insertable(exTask).ExecuteCommand();

                    #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 new Exception(wcsModel.Msg);
                        }
                    }
                    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();
                throw new Exception(e.Message);
            }

        }

        //获取平库托盘信息
        public List<BoxInfo> GetPingKuInfoByPallet(string soNo, string palletNo)
        {
            try
            {
                var info = Db.Queryable<BllExportAllot>().Where(m => m.SONo == soNo && m.PalletNo == palletNo && m.IsDel == "0");
                if (info.Count() == 0)
                {
                    throw new Exception("未查询到托盘分配下发的信息");
                }

                var data = info.GroupBy(m => new { m.SkuNo, m.SkuName, m.LotNo }).Select(m => new BoxInfo()
                {
                    SkuNo = m.SkuNo,
                    SkuName = m.SkuName,
                    LotNo = m.LotNo
                }).ToList();

                return data;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

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

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

                #region 托盘是否在平库验证

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

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

                #endregion

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

                Db.BeginTran();

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

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

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

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

                            continue;
                        }
                        item.LocatNo = "";//储位更改（改为空）
                        item.WareHouseNo = "";//所属仓库更改（改为空）
                        item.RoadwayNo = "";//所属巷道更改（改为空）
                        item.AreaNo = "";//所属区域更改（改为空）
                        Db.Updateable(item).ExecuteCommand();
                    }
                    //出库流水（更改状态）
                    var allot = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.Status == "1" && m.PalletNo == palletNo && m.SONo == soNo).ToList();

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

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

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

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

                    #endregion

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