using Dm;
using Model.InterFaceModel;
using Model.ModelDto.BllSoDto;
using Model.ModelDto.DataDto;
using Model.ModelVm.BllSoVm;
using Model.ModelVm.DataVm;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Utility.Tools;
using WMS.BLL.DataServer;
using WMS.BLL.Logic;
using WMS.BLL.LogServer;
using WMS.DAL;
using WMS.Entity.BllAsnEntity;
using WMS.Entity.BllSoEntity;
using WMS.Entity.Context;
using WMS.Entity.DataEntity;
using WMS.Entity.LogEntity;
using WMS.Entity.SysEntity;
using WMS.IBLL.IBllSoServer;

namespace WMS.BLL.BllSoServer
{
    public class ExportNoticeServer : DbHelper<BllExportNotice>, IExportNoticeServer
    {
        private static readonly SqlSugarScope Db = DataContext.Db;
        public ExportNoticeServer() : base(Db)
        {
        }

        #region 上游接口

        /// <summary>
        /// 创建出库单据
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool ErpAddExportNotice(SoInfo model)
        {
            try
            {
                if (string.IsNullOrEmpty(model.SoType))
                {
                    throw new Exception("单据类型不可为空!");
                }
                if (string.IsNullOrEmpty(model.Customer))
                {
                    throw new Exception("客户不可为空!");
                }
                if (string.IsNullOrEmpty(model.OrderCode))
                {
                    throw new Exception("系统单号不可为空!");
                }
                if (model.SoDetails.Count <= 0)
                {
                    throw new Exception("出库单明细不可为空!");
                }
                var skuNos = model.SoDetails.Select(a => a.SkuNo).Distinct().ToList();
                //根据物料号获取物料信息、库存明细中获取批次描述供货批次等
                var skuList = Db.Queryable<SysMaterials>().Where(a => skuNos.Contains(a.SkuNo) && a.IsDel == "0").ToList();
                var stockList = Db.Queryable<DataStock>().Where(s => skuNos.Contains(s.SkuNo) && (s.Qty - s.FrozenQty - s.LockQty) > 0).ToList();

                //客户信息
                var customer = Db.Queryable<SysCustomer>().First(m => m.IsDel == "0" && m.CustomerNo == model.Customer);
                if (customer == null)
                {
                    throw new Exception("客户不可为空!");
                }
                var logistics = Db.Queryable<SysLogisticsInfo>().First(m => m.IsDel == "0" && m.CarrierName == model.LogisticsNo);
                int? logisticsId = null;
                if (logistics != null)
                {
                    logisticsId = logistics.Id;
                }
                var billNo = "";
                var bl = true;
                do
                {
                    //获取自增单据号
                    billNo = new Common().GetMaxNo("SO");
                    var no = billNo;
                    bl = Db.Queryable<BllExportNotice>().Any(m => m.SONo == no);
                } while (bl);


                Db.BeginTran();//开启事务

                try
                {
                    var list = new List<BllExportNoticeDetail>();
                    //添加出库单
                    foreach (var d in model.SoDetails)
                    {
                        if (d.Qty < 1)
                        {
                            throw new Exception("出库数量必须大于0");
                        }
                        var sku = skuList.FirstOrDefault(a => a.SkuNo == d.SkuNo);
                        if (sku == null)
                        {
                            throw new Exception($"物料信息中未查询到出库物料信息:{d.SkuNo}");
                        }
                        //库存
                        List<DataStock> stocks;
                        if (!string.IsNullOrWhiteSpace(d.LotNo))
                        {
                            stocks = stockList.Where(s => s.SkuNo == d.SkuNo && s.LotNo == d.LotNo).ToList();
                        }
                        else
                        {
                            stocks = stockList.Where(s => s.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(s.LotNo)).ToList();
                        }
                        if (stocks.Count < 1)
                        {
                            throw new Exception($"总库存中未查询到出库物料信息:{d.SkuNo}");
                        }

                        var item = new BllExportNoticeDetail()
                        {
                            SONo = billNo,
                            SkuNo = sku.SkuNo,
                            SkuName = sku.SkuName,
                            Standard = sku.Standard,
                            LotNo = d.LotNo,
                            LotText = "",
                            Qty = d.Qty,
                            AllotQty = 0,
                            FactQty = 0,
                            CompleteQty = 0,
                            PackagNo = sku.PackagNo,
                            Price = sku.Price,
                            Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * d.Qty,
                            IsBale = "",
                            IsBelt = "",
                            SupplierLot = stocks.First().SupplierLot,
                            IsWave = "0",
                            WaveNo = "",

                            CreateUser = 0,
                        };
                        list.Add(item);
                        stocks.First().LockQty += d.Qty;//锁定数量

                        var i = Db.Updateable(stocks.First()).UpdateColumns(it => new { it.LockQty })
                            .ExecuteCommand();

                    }
                    var notice = new BllExportNotice()
                    {
                        SONo = billNo,
                        Type = model.SoType,
                        Status = "0",
                        Origin = "WMS",
                        CustomerNo = model.Customer,
                        CustomerName = customer.CustomerName,
                        LogisticsId = logisticsId,
                        IsWave = "0",
                        WaveNo = "",
                        IsDespatch = "0",

                        CreateUser = 0,
                    };

                    var n = Db.Insertable<BllExportNotice>(notice).ExecuteCommand();
                    var m = Db.Insertable<BllExportNoticeDetail>(list).ExecuteCommand();

                    if (n <= 0 || m <= 0)
                    {
                        Db.RollbackTran();
                        return false;
                    }
                    Db.CommitTran();
                    return true;

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


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

        //回传出库单
        public bool FinishSo(int id, string url, int userId)
        {
            try
            {
                var notice = Db.Queryable<BllExportNotice>().First(m => m.Id == id && m.IsDel == "0");
                if (notice == null)
                {
                    throw new Exception("未查询到单据信息");
                }
                var detail = Db.Queryable<BllExportNoticeDetail>().Where(m => m.SONo == notice.SONo && m.IsDel == "0").ToList();
                if (detail.Count == 0)
                {
                    throw new Exception("未查询到单据明细信息");
                }
                var list = new List<SoDetail>();
                foreach (var d in detail)
                {
                    var item = new SoDetail()
                    {
                        SkuNo = d.SkuNo,
                        LotNo = d.LotNo,
                        Qty = int.Parse(d.CompleteQty.ToString())
                    };
                    list.Add(item);
                }
                var soInfo = new SoInfo()
                {
                    OrderCode = notice.OrderCode,
                    SoDetails = list
                };
                // 通过接口发送至erp
                var jsonData = JsonConvert.SerializeObject(soInfo);

                var response = HttpHelper.DoPost(url, jsonData, "出库单完成上传", "ERP");

                //解析返回数据
                var obj = JsonConvert.DeserializeObject<ErpModel>(response);
                if (obj.Success != 0)
                {
                    throw new Exception("上传失败" + obj.Message);
                }
                notice.Status = "6";
                notice.UpdateTime = DateTime.Now;
                notice.UpdateUser = userId;
                Db.Updateable(notice).ExecuteCommand();
                return true;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        #endregion

        #region 基础功能

        public List<ExportNoticeDto> GetExportNoticeList(string no, string type, string status, string SkuNo, string lotNo, int? logisticsId, string isWave, string isDespatch, string waveNo, string StartTime, string EndTime, int page, int limit, out int count)
        {
            try
            {
                var strList = new List<string>();

                if (!string.IsNullOrWhiteSpace(lotNo))
                {
                    var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.LotNo.Contains(lotNo.Trim())).Select(m => m.SONo).Distinct().ToList();
                    strList = detailList;
                }
                Expression<Func<BllExportNotice, bool>> item = Expressionable.Create<BllExportNotice>()
                    .AndIF(!string.IsNullOrWhiteSpace(no), it => it.SONo.Contains(no.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(type), it => it.Type == type)
                    .AndIF(!string.IsNullOrWhiteSpace(status), it => it.Status == status)
                    .AndIF(string.IsNullOrWhiteSpace(status), it => it.Status == "0" || it.Status == "1" || it.Status == "2" || it.Status == "3")
                    //.AndIF(!string.IsNullOrWhiteSpace(SkuNo), it => it.== status)
                    .AndIF(logisticsId != null, it => it.LogisticsId == logisticsId)
                    .AndIF(!string.IsNullOrWhiteSpace(isWave), it => it.IsWave == isWave)
                    .AndIF(!string.IsNullOrWhiteSpace(isDespatch), it => it.IsDespatch == isDespatch)
                    .AndIF(!string.IsNullOrWhiteSpace(waveNo), it => it.WaveNo.Contains(waveNo.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(lotNo), it => strList.Contains(it.SONo))
                    .AndIF(!string.IsNullOrWhiteSpace(StartTime), it => it.CreateTime >= Convert.ToDateTime(StartTime))
                    .AndIF(!string.IsNullOrWhiteSpace(EndTime), it => it.CreateTime <= Convert.ToDateTime(EndTime))
                    .ToExpression();//注意 这一句 不能少
                var total = 0;
                var data = GetAllWhereAsync(item)
                    .LeftJoin<BllExportNoticeDetail>((a, b) => a.SONo == b.SONo)
                    .WhereIF(!string.IsNullOrWhiteSpace(SkuNo), (a, b) => b.SkuNo == SkuNo)
                    .LeftJoin<SysLogisticsInfo>((a, b, c) => a.LogisticsId == c.Id)
                    .LeftJoin<SysUserInfor>((a, b, c, d) => a.CreateUser == d.Id)
                    .LeftJoin<SysUserInfor>((a, b, c, d, e) => a.CreateUser == e.Id)
                    .LeftJoin<SysPackag>((a, b, c, d, e, f) => b.PackagNo == f.PackagNo)
                    .Select((a, b, c, d, e, f) => new ExportNoticeDto()
                    {
                        Id = a.Id,
                        SONo = a.SONo,
                        Type = a.Type,
                        Status = a.Status,
                        Origin = a.Origin,
                        CustomerNo = a.CustomerNo,
                        CustomerName = a.CustomerName,

                        LogisticsId = a.LogisticsId,
                        LogisticsName = c.CarrierName,

                        IsDespatch = a.IsDespatch,

                        //明细字段

                        DetailId = b.Id,
                        DetailStatus = b.Status,

                        SkuNo = b.SkuNo,
                        SkuName = b.SkuName,
                        Standard = b.Standard,
                        LotNo = b.LotNo,
                        LotText = b.LotText,

                        Qty = b.Qty,
                        AllotQty = b.AllotQty,
                        FactQty = b.FactQty,
                        CompleteQty = b.CompleteQty,

                        PackagNo = f.PackagNo,
                        PackagName = f.PackagName,
                        Price = b.Price,
                        Money = b.Money,
                        IsBale = b.IsBale,
                        IsBelt = b.IsBelt,
                        SupplierLot = b.SupplierLot,
                        IsWave = a.IsWave,
                        WaveNo = a.WaveNo,

                        CreateUserName = d.RealName,
                        UpdateUserName = e.RealName,
                        CreateTime = a.CreateTime,
                        UpdateTime = a.UpdateTime
                    })
                    .OrderByDescending(a => a.CreateTime)
                    .ToOffsetPage(page, limit, ref total);

                count = total;

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

        //添加出库单选择库存明细数据源
        public List<ExStockInfoDto> GetStockGroupList(string wareHouseNo, string type, string lotNo, string skuNo)
        {
            try
            {
                var plnList = new List<string>() { "100099", "100098", "100097", "100096", "100095" };
                var skuList = new List<string>();
                var sku = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0" && !plnList.Contains(m.SkuNo)); //排除空托盘的物料集合
                var inspectStatus = "";//库存内物料的质检状态
                var skuTypeC = new List<string>();//成品
                var skuTypeY = new List<string>();//原料
                skuTypeC = new List<string>() { "2", "4" };//成品
                skuTypeY = new List<string>() { "0", "1", "3" };//原料
                if (type == "8")
                {
                    skuTypeC = new List<string>() { "8" }; //其它
                    skuTypeY = new List<string>();
                }
                if (type == "0" || type == "1")
                {
                    inspectStatus = "1";
                    if (type == "0") //成品
                    {
                        skuList = sku.Where(m => skuTypeC.Contains(m.Type)).Select(m => m.SkuNo).ToList();
                    }

                    if (type == "1") //原料
                    {
                        skuList = sku.Where(m => skuTypeY.Contains(m.Type)).Select(m => m.SkuNo).ToList();
                    }
                }
                else if (type == "2" || type == "3")
                {
                    inspectStatus = "2";
                    if (type == "2") //成品
                    {
                        skuList = sku.Where(m => skuTypeC.Contains(m.Type)).Select(m => m.SkuNo).ToList();
                    }

                    if (type == "3") //原料
                    {
                        skuList = sku.Where(m => skuTypeY.Contains(m.Type)).Select(m => m.SkuNo).ToList();
                    }
                }
                else if (type == "8")
                {
                    inspectStatus = "1";
                    skuList = sku.Where(m => skuTypeC.Contains(m.Type)).Select(m => m.SkuNo).ToList();
                }
                else if (type == "4" || type == "5")
                {
                    inspectStatus = "0";
                    skuList = sku.Select(m => m.SkuNo).ToList();
                }
                else
                {
                    throw new Exception("单据状态有误");
                }

                //获取未禁用巷道的巷道号
                var OpenRoadwayNo = Db.Queryable<SysStorageRoadway>()
                    .Where(a => a.IsDel == "0" && a.WareHouseNo == "W03" && a.Status == "0")
                    .Select(a => a.RoadwayNo)
                    .ToList();

                if (OpenRoadwayNo.Count == 0)
                {
                    throw new Exception("所有巷道都已被禁用 无法查看可出库库存信息");
                }

                var stockRst = new StockServer();
                var stockDetailRst = new StockDetailServer();
                Expression<Func<DataStockDetail, bool>> item = Expressionable.Create<DataStockDetail>()
                    //.And(it => it.WareHouseNo == wareHouseNo)//仓库
                    .And(it => OpenRoadwayNo.Contains(it.RoadwayNo)) //未禁用巷道
                    .AndIF(!string.IsNullOrWhiteSpace(inspectStatus), it => it.InspectStatus == inspectStatus)
                    .And(m => skuList.Contains(m.SkuNo))
                    .AndIF(!string.IsNullOrWhiteSpace(lotNo), it => it.LotNo.Contains(lotNo))
                    .AndIF(!string.IsNullOrWhiteSpace(skuNo), it => it.SkuNo.Contains(skuNo))
                    .And(it => (it.Qty - it.LockQty - it.FrozenQty) > 0)
                    .ToExpression();//注意 这一句 不能少
                //库存明细
                var stockDetail = stockDetailRst.GetAllWhereAsync(item).GroupBy(m => new
                {
                    m.SkuNo,
                    m.SkuName,
                    m.LotNo,
                    m.Standard,

                }).Select(it => new ExStockInfoDto
                {
                    SkuNo = it.SkuNo,
                    SkuName = it.SkuName,
                    LotNo = it.LotNo,
                    Standard = it.Standard,
                    Qty = SqlFunc.AggregateSumNoNull(it.Qty - it.LockQty - it.FrozenQty)

                }).ToList();


                //库存总表
                var stock = stockRst.GetAllAsync().Select(it => new ExStockInfoDto
                {
                    SkuNo = it.SkuNo,
                    SkuName = it.SkuName,
                    LotNo = it.LotNo,
                    Standard = it.Standard,
                    Qty = type == "4" ? it.Qty : it.Qty - it.LockQty - it.FrozenQty

                }).ToList();

                foreach (var l in stockDetail.ToArray())
                {
                    var fq = stock.Where(s => s.SkuNo == l.SkuNo);
                    if (!string.IsNullOrWhiteSpace(l.LotNo))
                    {
                        fq = fq.Where(s => s.LotNo == l.LotNo);
                    }
                    else
                    {
                        fq = fq.Where(s => string.IsNullOrWhiteSpace(s.LotNo));
                    }
                    var f = fq.FirstOrDefault();
                    if (f == null)
                    {
                        throw new Exception("库存信息错误，请核实");
                    }
                    if (f.Qty != null && f.Qty.Value < l.Qty)
                    {
                        l.Qty = f.Qty.Value;
                    }
                    if (l.Qty <= 0)
                    {
                        stockDetail.Remove(l);
                    }
                }

                return stockDetail;

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

        //WMS添加出库单
        public bool AddExportNotice(AddEditExportNoticeVm model, int userId)
        {
            try
            {
                if (model == null || model.Detail.Count == 0)
                {
                    throw new Exception("参数异常");
                }
                var skuNos = model.Detail.Select(a => a.SkuNo).Distinct().ToList();
                //根据物料号获取物料信息、库存明细中获取批次描述供货批次等
                var skuList = Db.Queryable<SysMaterials>().Where(a => skuNos.Contains(a.SkuNo) && a.IsDel == "0").ToList();
                var stockList = Db.Queryable<DataStock>().Where(s => skuNos.Contains(s.SkuNo) && (s.Qty - s.FrozenQty - s.LockQty) > 0).ToList();
                //var palletList = contextDb.Queryable<DataStockDetail>().Where(s => skuNos.Contains(s.SkuNo) && (s.Qty - s.FrozenQty - s.LockQty) > 0).ToList();
                //客户信息
                var customer = Db.Queryable<SysCustomer>().Where(m => m.IsDel == "0" && m.CustomerNo == model.CustomerNo).ToList();
                var billNo = "";
                var bl = true;
                do
                {
                    //获取自增单据号
                    billNo = new Common().GetMaxNo("SO");
                    var no = billNo;
                    bl = Db.Queryable<BllExportNotice>().Any(m => m.SONo == no);
                } while (bl);


                Db.BeginTran();//开启事务

                try
                {
                    var list = new List<BllExportNoticeDetail>();
                    //添加出库单
                    foreach (var d in model.Detail)
                    {
                        if (d.Qty < 1)
                        {
                            throw new Exception("出库数量必须大于0");
                        }
                        var sku = skuList.FirstOrDefault(a => a.SkuNo == d.SkuNo);
                        if (sku == null)
                        {
                            throw new Exception($"物料信息中未查询到出库物料信息:{d.SkuNo}");
                        }
                        //库存
                        List<DataStock> stocks;
                        //List<DataStockDetail> pallets;
                        if (!string.IsNullOrWhiteSpace(d.LotNo))
                        {
                            stocks = stockList.Where(s => s.SkuNo == d.SkuNo && s.LotNo == d.LotNo).ToList();
                            //pallets = palletList.Where(p => p.SkuNo == d.SkuNo && p.LotNo == d.LotNo).ToList();
                        }
                        else
                        {
                            stocks = stockList.Where(s => s.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(s.LotNo)).ToList();
                            //pallets = palletList.Where(p => p.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(p.LotNo)).ToList();
                        }
                        if (stocks.Count < 1)
                        {
                            throw new Exception($"总库存中未查询到出库物料信息:{d.SkuNo}");
                        }

                        //判断数量
                        var qty = stocks.First().Qty - stocks.First().LockQty - stocks.First().FrozenQty;
                        if (d.Qty > qty)
                        {
                            throw new Exception($"总库存中出库物料信息:{d.SkuNo}、{d.LotNo} 库存数量不足");
                        }

                        var item = new BllExportNoticeDetail()
                        {
                            SONo = billNo,
                            SkuNo = sku.SkuNo,
                            SkuName = sku.SkuName,
                            Standard = sku.Standard,
                            LotNo = d.LotNo,
                            LotText = "",
                            Status = "0",
                            Qty = d.Qty,
                            AllotQty = 0,
                            FactQty = 0,
                            CompleteQty = 0,
                            PackagNo = sku.PackagNo,
                            Price = sku.Price,
                            Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * d.Qty,
                            IsBale = model.Type != "8" ? d.IsBale : "0",
                            IsBelt = model.Type != "8" ? d.IsBelt : "0",
                            SupplierLot = stocks.First().SupplierLot,
                            IsWave = string.IsNullOrWhiteSpace(d.IsWave) ? "1" : d.IsWave, //08暂定是否拆桶
                            WaveNo = "",

                            CreateUser = userId,
                        };
                        list.Add(item);
                        if (model.Type != "4")
                        {
                            //stocks.First().LockQty += d.Qty;//锁定数量
                        }

                        //var i = Db.Updateable(stocks.First()).UpdateColumns(it => new { it.LockQty }).ExecuteCommand();

                    }
                    var notice = new BllExportNotice()
                    {
                        SONo = billNo,
                        Type = model.Type,
                        Status = "0",
                        Origin = "WMS",
                        CustomerNo = model.CustomerNo,
                        CustomerName = customer.FirstOrDefault() == null ? "" : customer.First().CustomerName,
                        LogisticsId = model.LogisticsId,
                        IsWave = "0",
                        WaveNo = "",
                        IsDespatch = "0",

                        CreateUser = userId,
                    };

                    var n = Db.Insertable<BllExportNotice>(notice).ExecuteCommand();
                    var m = Db.Insertable<BllExportNoticeDetail>(list).ExecuteCommand();

                    if (n <= 0 || m <= 0)
                    {
                        Db.RollbackTran();
                        return false;
                    }
                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", billNo, "添加", $"添加了单据号为{billNo}的单据信息", userId);
                    Db.CommitTran();
                    return true;

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

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

        //获取编辑出库单及明细信息
        public EditExportNotifyDto GetEditExportNotice(string code)
        {
            try
            {
                var notify = Db.Queryable<BllExportNotice>().Where(m => m.SONo == code && m.IsDel == "0").ToList().FirstOrDefault();
                if (notify == null)
                {
                    throw new Exception($"未查询到{code}的单据信息");
                }

                var detail = Db.Queryable<BllExportNoticeDetail>().Where(m => m.SONo == code && m.IsDel == "0").ToList();
                var skuList = detail.Select(m => m.SkuNo).ToList();
                var stock = Db.Queryable<DataStock>().Where(m => skuList.Contains(m.SkuNo) && m.IsDel == "0").ToList();


                var model = new EditExportNotifyDto
                {
                    SoNo = notify.SONo,
                    Type = notify.Type,
                    CustomerNo = notify.CustomerNo,
                    LogisticsId = notify.LogisticsId,
                    //ExportWarehouseId = notify.ExportWarehouseId,
                };
                model.Detail = new List<SelectStockSkuDto>();
                DataStock s;
                foreach (var d in detail)
                {
                    if (string.IsNullOrWhiteSpace(d.LotNo))
                    {
                        s = stock.FirstOrDefault(m => m.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(m.LotNo));
                    }
                    else
                    {
                        s = stock.FirstOrDefault(m => m.SkuNo == d.SkuNo && m.LotNo == d.LotNo);
                    }

                    var stockCount = 0; //st.StockQuantity.Value
                    if (s != null)
                    {
                        stockCount = s.Qty - s.FrozenQty - s.LockQty;
                    }

                    var dm = new SelectStockSkuDto()
                    {
                        SkuNo = d.SkuNo,
                        SkuName = d.SkuName,
                        Standard = d.Standard,
                        LotNo = d.LotNo,
                        Qty = stockCount,
                        ExQty = d.Qty,
                        IsBale = d.IsBale,
                        IsBelt = d.IsBelt
                    };
                    model.Detail.Add(dm);
                }

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

        //修改出库单
        public bool EditExportNotice(AddEditExportNoticeVm model, int userId)
        {
            try
            {
                if (model == null || model.Detail.Count == 0)
                {
                    throw new Exception("参数异常");
                }

                var notice = Db.Queryable<BllExportNotice>().Where(m => m.IsDel == "0" && m.Id == model.Id).ToList().FirstOrDefault();
                if (notice == null)
                {
                    throw new Exception("未查询到出库单据信息");
                }
                if (notice.Origin != "WMS" || notice.Status != "0")
                {
                    throw new Exception("参数异常,请检查状态是否未等待执行或来源是否是WMS");
                }
                //出库单明细
                var noticeDetail = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == notice.SONo).ToList();

                //根据物料号获取物料信息、库存明细中获取批次描述供货批次等
                var skuList = Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0").ToList();
                var stockList = Db.Queryable<DataStock>().Where(s => (s.Qty - s.FrozenQty - s.LockQty) > 0).ToList();
                var palletList = Db.Queryable<DataStockDetail>().Where(s => (s.Qty - s.FrozenQty - s.LockQty) > 0).ToList();


                Db.BeginTran();//开启事务

                try
                {
                    //删除旧
                    foreach (var d in noticeDetail)
                    {
                        var mq = model.Detail.Where(o => o.SkuNo == d.SkuNo).ToList();
                        if (!string.IsNullOrWhiteSpace(d.LotNo))
                        {
                            mq = mq.Where(o => o.LotNo == d.LotNo).ToList();
                        }
                        if (mq.Any()) //如果有这个物料及批次则跳过
                        {
                            continue;
                        }
                        //
                        var fl = stockList.Where(s => s.SkuNo == d.SkuNo).ToList();
                        DataStock fls;
                        if (!string.IsNullOrWhiteSpace(d.LotNo))
                        {
                            fls = fl.FirstOrDefault(s => s.SkuNo == d.SkuNo && s.LotNo == d.LotNo);
                        }
                        else
                        {
                            fls = fl.FirstOrDefault(s => s.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(s.LotNo));
                        }
                        if (fls == null)
                        {
                            throw new Exception($"未找到物料{d.SkuNo}、批次{d.LotNo} 的库存信息");
                        }
                        //fls.LockQty -= d.Qty;
                        d.IsDel = "1";
                        d.UpdateUser = userId;
                        d.UpdateTime = DateTime.Now;
                        Db.Updateable(d).ExecuteCommand();
                        //Db.Updateable(fls).UpdateColumns(it => new { it.LockQty }).ExecuteCommand();
                    }

                    //更新出库单
                    foreach (var d in model.Detail)
                    {
                        if (d.Qty < 1)
                        {
                            throw new Exception("出库数据必须大于0");
                        }
                        var sku = skuList.FirstOrDefault(a => a.SkuNo == d.SkuNo);
                        if (sku == null)
                        {
                            throw new Exception("出库物品为空");
                        }
                        //库存
                        List<DataStock> stocks;
                        List<DataStockDetail> pallet;
                        if (!string.IsNullOrWhiteSpace(d.LotNo))
                        {
                            stocks = stockList.Where(s => s.SkuNo == d.SkuNo && s.LotNo == d.LotNo).ToList();
                            pallet = palletList.Where(p => p.SkuNo == d.SkuNo && p.LotNo == d.LotNo).ToList();
                        }
                        else
                        {
                            stocks = stockList.Where(s => s.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(s.LotNo)).ToList();
                            pallet = palletList.Where(p => p.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(p.LotNo)).ToList();
                        }

                        if (stocks.Count < 1)
                        {
                            throw new Exception("出库物品库存不足");
                        }
                        var stock = stocks.First();//总库存
                        //
                        BllExportNoticeDetail old;
                        if (string.IsNullOrWhiteSpace(d.LotNo))
                        {
                            old = noticeDetail.FirstOrDefault(o => o.SkuNo == d.SkuNo && string.IsNullOrWhiteSpace(o.LotNo));
                        }
                        else
                        {
                            old = noticeDetail.FirstOrDefault(o => o.SkuNo == d.SkuNo && o.LotNo == d.LotNo);
                        }

                        //新加项
                        if (old == null)
                        {
                            //判断数量
                            var qty = stock.Qty - stock.LockQty - stock.FrozenQty;
                            if (d.Qty > qty)
                            {
                                throw new Exception($"总库存中出库物料信息:{d.SkuNo}、{d.LotNo} 库存数量不足");
                            }

                            var item = new BllExportNoticeDetail()
                            {
                                SONo = notice.SONo,
                                SkuNo = sku.SkuNo,
                                SkuName = sku.SkuName,
                                Standard = sku.Standard,
                                LotNo = d.LotNo,
                                LotText = "",
                                Qty = d.Qty,
                                AllotQty = 0,
                                FactQty = 0,
                                CompleteQty = 0,
                                PackagNo = sku.PackagNo,
                                Price = sku.Price,
                                Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * qty,
                                IsBale = model.Type != "8" ? d.IsBale : "0",
                                IsBelt = model.Type != "8" ? d.IsBelt : "0",
                                SupplierLot = stocks.First().SupplierLot,
                                IsWave = "0",
                                WaveNo = "",

                                CreateUser = userId,
                            };

                            //stock.LockQty += d.Qty;//锁定数量
                            var m = Db.Insertable<BllExportNoticeDetail>(item).ExecuteCommand();
                            //var i = Db.Updateable(stock).UpdateColumns(it => new { it.LockQty }).ExecuteCommand();
                        }
                        else if (old.Qty != d.Qty || old.IsBale != d.IsBale || old.IsBelt != d.IsBelt)
                        {
                            if (d.Qty > stock.Qty - stock.FrozenQty - stock.LockQty + old.Qty)
                            {
                                throw new Exception("物品库存数量不足");
                            }
                            //增加
                            if (d.Qty > old.Qty)
                            {
                                //stock.LockQty += d.Qty - old.Qty;
                            }
                            else
                            {
                                //stock.LockQty -= old.Qty - d.Qty;
                            }
                            old.IsBale = d.IsBale;
                            old.IsBelt = d.IsBelt;
                            old.Qty = d.Qty;
                            old.UpdateUser = userId;
                            old.UpdateTime = DateTime.Now;
                            var m = Db.Updateable(old).UpdateColumns(it => new { it.IsBale, it.IsBelt, it.Qty, it.UpdateUser, it.UpdateTime }).ExecuteCommand();
                            //var i = Db.Updateable(stock).UpdateColumns(it => new { it.LockQty }).ExecuteCommand();
                        }
                    }

                    //客户信息
                    var customer = Db.Queryable<SysCustomer>().Where(m => m.IsDel == "0" && m.CustomerNo == model.CustomerNo).ToList().FirstOrDefault();
                    notice.Type = model.Type;
                    notice.CustomerNo = model.CustomerNo;
                    notice.CustomerName = customer == null ? "" : customer.CustomerName;
                    notice.LogisticsId = model.LogisticsId;
                    notice.UpdateUser = userId;
                    notice.UpdateTime = DateTime.Now;

                    var n = Db.Updateable(notice).ExecuteCommand();
                    if (n <= 0)
                    {
                        Db.RollbackTran();
                        return false;
                    }
                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", notice.SONo, "编辑", $"编辑了单据号为{notice.SONo}的单据信息", userId);
                    Db.CommitTran();
                    return true;

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

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

        //删除出库单
        public bool DelExportNotice(int id, int userId)
        {
            try
            {
                var notice = Db.Queryable<BllExportNotice>().Where(m => m.IsDel == "0" && m.Id == id).ToList().FirstOrDefault();
                if (notice == null)
                {
                    throw new Exception("未查询到出库单据信息");
                }
                //总库存信息
                var stockList = Db.Queryable<DataStock>().ToList();
                //出库单明细
                var noticeDetail = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == notice.SONo).ToList();
                int a = 0;
                if (notice.Origin != "WMS" || notice.Status != "0")
                {
                    //判断单据是否为正在执行且分配数量小于计划数量
                    if (notice.Status == "3" || noticeDetail[0].Qty > noticeDetail[0].AllotQty)
                    {
                        a = 1;
                    }
                    else
                    {
                        throw new Exception("参数异常,请检查状态是否未等待执行或来源是否是WMS");
                    }
                }


                Db.BeginTran();//开启事务
                try
                {
                    foreach (var d in noticeDetail)
                    {
                        //总库存
                        //var sq = stockList.Where(s => s.SkuNo == d.SkuNo);
                        //if (!string.IsNullOrWhiteSpace(d.LotNo))
                        //{
                        //    sq = sq.Where(s => s.LotNo == d.LotNo);
                        //}
                        //else
                        //{
                        //    sq = sq.Where(s => string.IsNullOrWhiteSpace(s.LotNo));
                        //}
                        //var fd = sq.FirstOrDefault();
                        //if (fd == null)
                        //{
                        //    throw new Exception($"未找到物料{d.SkuNo}、批次{d.LotNo} 的库存信息");
                        //}
                        //fd.LockQty -= d.Qty;
                        if (a == 1)
                        {
                            d.Status = "3";
                            d.UpdateUser = userId;
                            d.UpdateTime = DateTime.Now;
                        }
                        else
                        {
                            d.IsDel = "1";
                            d.UpdateUser = userId;
                            d.UpdateTime = DateTime.Now;
                        }

                        Db.Updateable(d).ExecuteCommand();
                        //Db.Updateable(fd).UpdateColumns(it => new { it.LockQty }).ExecuteCommand();
                    }
                    //删除出库单
                    if (a == 1)
                    {
                        notice.Status = "4";
                        notice.UpdateUser = userId;
                        notice.UpdateTime = DateTime.Now;
                    }
                    else
                    {
                        notice.IsDel = "1";
                        notice.UpdateUser = userId;
                        notice.UpdateTime = DateTime.Now;
                    }

                    var n = Db.Updateable(notice).ExecuteCommand();
                    if (n <= 0)
                    {
                        Db.RollbackTran();
                        return false;
                    }
                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", notice.SONo, "删除", $"删除了单据号为{notice.SONo}的单据信息", userId);

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

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

        //订单关闭
        public bool CloseExportNotice(int id, int userId)
        {
            try
            {
                var notice = Db.Queryable<BllExportNotice>().Where(m => m.IsDel == "0" && m.Id == id).ToList().FirstOrDefault();
                if (notice == null)
                {
                    throw new Exception("未查询到出库单据信息");
                }
                if (notice.Status != "4")
                {
                    throw new Exception("参数异常,请检查状态是否为执行完成或订单关闭");
                }
                //总库存信息
                //var stockList = Db.Queryable<DataStock>().ToList();
                ////出库单明细
                //var noticeDetail = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == notice.SONo).ToList();
                Db.BeginTran();//开启事务

                try
                {
                    //修改出库单状态
                    notice.Status = "5";
                    notice.UpdateUser = userId;
                    notice.UpdateTime = DateTime.Now;
                    Db.Updateable(notice).ExecuteCommand();

                    #region JC08关单无用代码

                    //var skuList = noticeDetail.Select(d => d.SkuNo).ToList();
                    //var stocks = stockList.Where(s => skuList.Contains(s.SkuNo)).ToList();

                    //foreach (var d in noticeDetail)
                    //{
                    //    if (d.Qty != d.CompleteQty)
                    //    {
                    //        throw new Exception("当前单据明细中计划数量与拣货数量不符，请核实");
                    //    }
                    //}
                    //foreach (var d in noticeDetail)
                    //{
                    //更改库存明细锁定数量
                    //var orders = dataContext.WmsExportOrder.Where(o => o.ExportDetailId == d.Id
                    //                && o.ExportExecuteFlag != "4" && o.ExportExecuteFlag == "3" && o.pickingType == 0).ToList();
                    //foreach (var o in orders)
                    //{
                    //    if (o.ExportQuantity > o.PickedNum) //判断拣货是否已拣完
                    //    {
                    //        var pq = dataContext.WmsStockTray.Where(t => t.StockGoodId == o.ExportGoodsCode && t.StockStockCode == o.ExportStockCode);

                    //        if (string.IsNullOrWhiteSpace(o.ExportLotNo))
                    //        {
                    //            pq = pq.Where(t => t.StockLotNo == null || t.StockLotNo == "");
                    //        }
                    //        else
                    //        {
                    //            pq = pq.Where(t => t.StockLotNo == o.ExportLotNo);
                    //        }
                    //        var pallet = pq.FirstOrDefault();
                    //        //库存托盘信息锁定数量还原为未锁定
                    //        if (pq != null)
                    //        {
                    //            pallet.LockQuantity -= o.ExportQuantity.Value - o.PickedNum;
                    //            pallet.StockQuantity += o.ExportQuantity.Value - o.PickedNum;
                    //        }
                    //    }
                    //}
                    //库存表减去锁定数量与总数量
                    //var sq = stocks.Where(s => s.SkuNo == d.SkuNo);
                    //if (!string.IsNullOrWhiteSpace(d.LotNo))
                    //{
                    //    sq = sq.Where(s => s.LotNo == d.LotNo);
                    //}
                    //else
                    //{
                    //    sq = sq.Where(s => string.IsNullOrWhiteSpace(s.LotNo));
                    //}
                    //var st = sq.FirstOrDefault();
                    //if (st == null)
                    //{
                    //    throw new Exception($"未找到物料{d.SkuNo}、批次{d.LotNo} 的库存信息");
                    //}
                    //if (d.CompleteQty <= d.Qty)
                    //{
                    //    st.Qty += d.Qty - d.CompleteQty.Value;
                    //}
                    //else
                    //{
                    //    st.Qty -= d.CompleteQty.Value - d.Qty;
                    //}
                    //st.LockQty -= d.Qty;
                    //st.Qty -= d.Qty;
                    ////修改总库存表
                    //Db.Updateable(st).UpdateColumns(it => new { it.Qty, it.LockQty }).ExecuteCommand();
                    //}

                    #endregion

                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", notice.SONo, "关单", $"关闭了单据号为{notice.SONo}的单据信息", userId);

                    Db.CommitTran();
                    return true;
                }
                catch (Exception e)
                {
                    Db.RollbackTran();
                    throw new Exception(e.Message);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("关闭出库单据失败：" + ex.Message);
            }
        }


        //批量订单关闭
        public bool CloseExportNotices(List<int> ids, int userId)
        {
            try
            {
                //string arr = ids[0].ToString();
                //foreach (var item in ids)
                //{
                //    if (item != ids[0])
                //    {
                //        arr += ',' + item.ToString();
                //    }

                //}
                //string str = $"select * from BllExportNotice where IsDel = '0' and Id in ({arr})";
                //var notice = Db.Ado.SqlQuery<BllExportNotice>(str);
                var notice = GetAllWhereAsync(m => ids.Contains(m.Id)).ToList();

                if (notice.Count == 0)
                {
                    throw new Exception("未查询到出库单据信息");
                }
                foreach (var item in notice)
                {
                    if (item.Status != "4")
                    {
                        throw new Exception("参数异常,请检查选中单据状态是否为执行完成");
                    }
                }

                //总库存信息
                //var stockList = Db.Queryable<DataStock>().ToList();
                ////出库单明细
                //var noticeDetail = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == notice.SONo).ToList();
                Db.BeginTran();//开启事务

                try
                {
                    foreach (var item in notice)
                    {
                        //修改出库单状态
                        item.Status = "5";
                        item.UpdateUser = userId;
                        item.UpdateTime = DateTime.Now;
                        Db.Updateable(notice).ExecuteCommand();

                        #region JC08关单无用代码

                        //var skuList = noticeDetail.Select(d => d.SkuNo).ToList();
                        //var stocks = stockList.Where(s => skuList.Contains(s.SkuNo)).ToList();

                        //foreach (var d in noticeDetail)
                        //{
                        //    if (d.Qty != d.CompleteQty)
                        //    {
                        //        throw new Exception("当前单据明细中计划数量与拣货数量不符，请核实");
                        //    }
                        //}
                        //foreach (var d in noticeDetail)
                        //{
                        //更改库存明细锁定数量
                        //var orders = dataContext.WmsExportOrder.Where(o => o.ExportDetailId == d.Id
                        //                && o.ExportExecuteFlag != "4" && o.ExportExecuteFlag == "3" && o.pickingType == 0).ToList();
                        //foreach (var o in orders)
                        //{
                        //    if (o.ExportQuantity > o.PickedNum) //判断拣货是否已拣完
                        //    {
                        //        var pq = dataContext.WmsStockTray.Where(t => t.StockGoodId == o.ExportGoodsCode && t.StockStockCode == o.ExportStockCode);

                        //        if (string.IsNullOrWhiteSpace(o.ExportLotNo))
                        //        {
                        //            pq = pq.Where(t => t.StockLotNo == null || t.StockLotNo == "");
                        //        }
                        //        else
                        //        {
                        //            pq = pq.Where(t => t.StockLotNo == o.ExportLotNo);
                        //        }
                        //        var pallet = pq.FirstOrDefault();
                        //        //库存托盘信息锁定数量还原为未锁定
                        //        if (pq != null)
                        //        {
                        //            pallet.LockQuantity -= o.ExportQuantity.Value - o.PickedNum;
                        //            pallet.StockQuantity += o.ExportQuantity.Value - o.PickedNum;
                        //        }
                        //    }
                        //}
                        //库存表减去锁定数量与总数量
                        //var sq = stocks.Where(s => s.SkuNo == d.SkuNo);
                        //if (!string.IsNullOrWhiteSpace(d.LotNo))
                        //{
                        //    sq = sq.Where(s => s.LotNo == d.LotNo);
                        //}
                        //else
                        //{
                        //    sq = sq.Where(s => string.IsNullOrWhiteSpace(s.LotNo));
                        //}
                        //var st = sq.FirstOrDefault();
                        //if (st == null)
                        //{
                        //    throw new Exception($"未找到物料{d.SkuNo}、批次{d.LotNo} 的库存信息");
                        //}
                        //if (d.CompleteQty <= d.Qty)
                        //{
                        //    st.Qty += d.Qty - d.CompleteQty.Value;
                        //}
                        //else
                        //{
                        //    st.Qty -= d.CompleteQty.Value - d.Qty;
                        //}
                        //st.LockQty -= d.Qty;
                        //st.Qty -= d.Qty;
                        ////修改总库存表
                        //Db.Updateable(st).UpdateColumns(it => new { it.Qty, it.LockQty }).ExecuteCommand();
                        //}

                        #endregion

                        //添加操作日志记录
                        var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", item.SONo, "关单", $"关闭了单据号为{item.SONo}的单据信息", userId);
                    }
                    Db.CommitTran();
                    return true;
                }
                catch (Exception e)
                {
                    Db.RollbackTran();
                    throw new Exception(e.Message);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("关闭出库单据失败：" + ex.Message);
            }
        }


        #endregion

        //------------------------------------------------------------------

        #region 下发出库、出库完成、重新下发任务、取消任务

        // 下发出库双深度库（调用cs接口给他库位地址）
        public List<OutCommandDto> IssueTwoOutHouse(string soNo, int userId, string url, out string str)
        {
            //测试url 发布服务器后删除
            //url = "http://localhost:57061/api/WCSApi/AddTasks";
            try
            {
                #region 集合 

                var outDto1 = new List<OutCommandDto>(); //先出库数据的集合（深度为1的储位）
                var outDto2 = new List<OutCommandDto>(); //后出库数据的集合（深度为2的储位）
                var moveDto = new List<OutCommandDto>(); //要移库数据的集合
                //记录错误信息的集合 
                var flagList = new List<int>();//1:当前要出库的储位正在移出、2 出库的托盘储位信息错误(在储位表中未查询到)、3储位损坏不能出库、4 要出库的托盘正在入库,5 双深度出库前面储位是入库中或者移入中

                #endregion
                var com = new Common();
                //assign.IsHavePyTask();
                var notice = Db.Queryable<BllExportNotice>().First(m => m.SONo == soNo && m.IsDel == "0");
                if (notice == null)
                {
                    throw new Exception($"未找到{soNo}出库单信息");
                }
                //所有要出库的出库分配信息(未下发的信息和待拣货的信息)
                var list = Db.Queryable<BllExportAllot>().Where(a => a.IsDel == "0" && a.SONo == soNo && (a.Status == "0" || (a.Status == "2" && a.CompleteQty == 0))).ToList();
                if (list.Count == 0) //判断是否有需要下发的出库流水
                {
                    throw new Exception("当前出库单据无需要下发的托盘");
                }

                #region 出库业务
                //要出库的托盘集合
                var outLpnList = list.Select(m => m.PalletNo).ToList();
                //要出库的明细集合
                var outStockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToList();
                Db.BeginTran();
                try
                {
                    //循环分配的信息生成出库任务
                    foreach (var item in list)
                    {
                        var taskNoStr = "";
                        var stockDetail = outStockDetail.First(m => m.PalletNo == item.PalletNo);
                        // 储位号
                        var locateNo = stockDetail.LocatNo;
                        //托盘上物料（用于判断物料是否是桶装类型）
                        var sku = Db.Queryable<SysMaterials>().First(m => m.SkuNo == item.SkuNo);
                        #region 判断

                        //判断托盘是否在库内(不在库内)
                        if (string.IsNullOrWhiteSpace(locateNo))
                        {
                            //判断托盘是否在入库中
                            var imBl = com.GetImTask(item.PalletNo);
                            if (imBl != null)
                            {
                                flagList.Add(4);
                                continue;
                            }
                            //（状态为待拣货的 1）
                            if (item.Status == "0")
                            {
                                //if (sku.Type == "2" || sku.Type == "3" || sku.Type == "4")//桶装类型手持拣货
                                //{
                                //}
                                //如果不在仓库内，当前分配信息直接更新出库完成 
                                item.Status = "2";//状态
                                //item.OutMode = "1号口";//出库口 
                                Db.Updateable(item).ExecuteCommand();
                                var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                                if (noticeDetail != null) //更新出库单据的下发数量
                                {
                                    noticeDetail.FactQty += item.Qty;
                                    Db.Updateable(noticeDetail).ExecuteCommand();
                                }

                                //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                                if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
                                {
                                    var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
                                    if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
                                    {
                                        notice.Status = "3"; //变更状态为正在执行
                                        Db.Updateable(notice).ExecuteCommand();
                                    }
                                }
                            }
                            continue;
                        }

                        var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo && m.IsDel == "0");//当前出库的储位信息
                        if (locate == null)
                        {
                            flagList.Add(2);
                            continue;
                        }
                        //判断储位标志是否为损坏
                        if (locate.Flag == "2")
                        {
                            flagList.Add(3);
                            continue;
                        }

                        #endregion

                        if (locate.Status == "1") //有物品
                        {
                            if (locate.Depth == "01") //深度为1
                            {
                                #region 添加出库任务

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

                                    StartLocat = locate.LocatNo,//起始位置
                                    EndLocat = "",//目标位置
                                    PalletNo = item.PalletNo,//托盘码
                                    IsSend = 1,//是否可再次下发
                                    IsCancel = 1,//是否可取消
                                    IsFinish = 1,//是否可完成
                                    Type = "1",//任务类型 0 入库任务 1 出库任务  2 移库任务
                                    Status = "0",//任务状态0：等待执行1正在执行2执行完成
                                    OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单
                                    Msg = locate.LocatNo + "的出库任务"
                                };
                                Db.Insertable(exTask).ExecuteCommand();

                                outDto1.Add(new OutCommandDto()
                                {
                                    SkuType = sku.Type, //物料类型
                                    StartRoadway = locate.RoadwayNo, //起始巷道
                                    PalletNo = item.PalletNo,//托盘号
                                    StartLocat = locate.LocatNo, // 起始位置
                                    EndLocat = "1", // 目标位置 
                                    TaskNo = exTask.TaskNo, // 任务号
                                    Type = "1",// 任务类型 (出库)
                                    OutMode = "1",  //目标地址
                                    Order = 1,
                                    LotNo = item.LotNo, // 批次
                                    IsBale = item.IsBale, //是否裹包
                                    IsBelt = item.IsBelt, //是否打带
                                    IsStacking1 = item.IsAdvance, //是否拆桶（08暂定）
                                    Qty = item.Qty, //拣货数量
                                    FullQty = (int)item.BoxexQty, //托盘数量
                                    PalletType = stockDetail.PalletType, //托盘类型(有无子托)0||空||null：无子托盘1：有子托盘
                                });
                                taskNoStr = exTask.TaskNo;
                                #endregion

                            }
                            else if (locate.Depth == "02") //深度为2
                            {
                                //获取出库深度为2储位前面的储位信息
                                var slotBefore = com.GetLocateNoDepth1(locate.WareHouseNo, locate.LocatNo);
                                if (slotBefore.Status == "1") //前面的储位有货物、进行移库操作
                                {
                                    //要出库深度为2的储位前面的储位中货物是否要出库
                                    var isout = outStockDetail.Count(m => m.LocatNo == slotBefore.LocatNo);

                                    if (isout <= 0) //进行移库
                                    {
                                        //去库存表中找到储位对应的托盘码操作
                                        var stockNew = Db.Queryable<DataStockDetail>().First(m => m.LocatNo == slotBefore.LocatNo);
                                        if (stockNew == null)
                                        {
                                            var slotChange = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == slotBefore.LocatNo);
                                            slotChange.Status = "0";
                                            Db.Updateable(slotChange).ExecuteCommand();
                                        }
                                        else
                                        {
                                            //获取移库的库位
                                            var newSlot = MoveAddress(slotBefore.LocatNo, slotBefore.RoadwayNo, slotBefore.AreaNo);
                                            //当前移库库位的储位信息
                                            var locatey = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == newSlot && m.IsDel == "0");
                                            if (!string.IsNullOrEmpty(newSlot))
                                            {
                                                #region 添加出库时发生的移库任务

                                                var exYkTaskNo = new Common().GetMaxNo("TK");
                                                var exYkTask = new LogTask    //出库时产生移库任务
                                                {
                                                    TaskNo = exYkTaskNo,
                                                    Sender = "WMS",
                                                    Receiver = "WCS",
                                                    IsSuccess = 0, //是否下发成功 0失败 1成功

                                                    StartLocat = stockNew.LocatNo,//起始位置
                                                    EndLocat = newSlot,//目标位置
                                                    PalletNo = stockNew.PalletNo,//托盘码
                                                    IsSend = 1,//是否可再次下发
                                                    IsCancel = 1,//是否可取消
                                                    IsFinish = 1,//是否可完成
                                                    Type = "2",//任务类型 0 入库任务 1 出库任务  2 移库任务
                                                    Status = "0",//任务状态0：等待执行1正在执行2执行完成
                                                    OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单

                                                    Msg = stockNew.LocatNo + " ==>> " + newSlot + "的移库任务",
                                                };
                                                Db.Insertable(exYkTask).ExecuteCommand();

                                                moveDto.Add(new OutCommandDto()
                                                {
                                                    SkuType = sku.Type, //物料类型
                                                    StartRoadway = slotBefore.RoadwayNo, //起始巷道
                                                    PalletNo = stockNew.PalletNo,//托盘号
                                                    StartLocat = stockNew.LocatNo, // 起始位置
                                                    EndLocat = newSlot, // 目标位置 
                                                    EndRoadway = locatey.RoadwayNo, // 目标巷道 
                                                    TaskNo = exYkTask.TaskNo, // 任务号
                                                    Type = "2",// 任务类型 (移库)
                                                    OutMode = "",  //目标地址
                                                    Order = 1,
                                                    LotNo = stockNew.LotNo,
                                                    Qty = 0, //拣货数量
                                                    FullQty = (int)stockNew.Qty, //托盘数量
                                                    PalletType = stockNew.PalletType, //托盘类型(有无子托)0||空||null：无子托盘1：有子托盘
                                                });
                                                #endregion

                                                #region 改变储位装填
                                                var slotChange = Db.Queryable<SysStorageLocat>().First(m => m.Id == slotBefore.Id);
                                                var slotChange2 = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == newSlot);
                                                slotChange.Status = "5"; //改变状态（正在移出）
                                                slotChange2.Status = "4"; // 改变状态（正在移入）
                                                Db.Updateable(slotChange).ExecuteCommand();
                                                Db.Updateable(slotChange2).ExecuteCommand();
                                                #endregion
                                            }
                                            else
                                            {
                                                #region 添加出库任务

                                                var exYkTaskNo1 = new Common().GetMaxNo("TK");
                                                var exYkTask1 = new LogTask    //出库移库没有库位了进行出库任务
                                                {
                                                    TaskNo = exYkTaskNo1,
                                                    Sender = "WMS",
                                                    Receiver = "WCS",
                                                    IsSuccess = 0, //是否下发成功 0失败 1成功

                                                    StartLocat = stockNew.LocatNo,//起始位置
                                                    EndLocat = "",//目标位置
                                                    PalletNo = stockNew.PalletNo,//托盘码
                                                    IsSend = 1,//是否可再次下发
                                                    IsCancel = 1,//是否可取消
                                                    IsFinish = 1,//是否可完成
                                                    Type = "1",//任务类型 0 入库任务 1 出库任务  2 移库任务
                                                    Status = "0",//任务状态0：等待执行1正在执行2执行完成
                                                    OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单
                                                    Msg = locate.LocatNo + "的出库任务"
                                                };
                                                Db.Insertable(exYkTask1).ExecuteCommand();

                                                outDto1.Add(new OutCommandDto()
                                                {
                                                    SkuType = sku.Type, //物料类型
                                                    StartRoadway = slotBefore.RoadwayNo, //起始巷道
                                                    PalletNo = stockNew.PalletNo,//托盘号
                                                    StartLocat = stockNew.LocatNo, // 起始位置
                                                    EndLocat = "", // 目标位置 
                                                    TaskNo = exYkTask1.TaskNo, // 任务号
                                                    Type = "1",// 任务类型 (出库)
                                                    OutMode = "",  //目标地址
                                                    Order = 1,
                                                    LotNo = "", // 批次
                                                    IsBale = "0", //是否裹包
                                                    IsBelt = "0", //是否打带
                                                    IsStacking1 = item.IsAdvance, //是否拆桶（08暂定）
                                                    Qty = 0, //拣货数量
                                                    FullQty = (int)stockNew.Qty, //托盘数量
                                                    PalletType = stockNew.PalletType, //托盘类型(有无子托)0||空||null：无子托盘1：有子托盘
                                                });
                                                #endregion

                                                #region MyRegion

                                                var slotChange = Db.Queryable<SysStorageLocat>().First(m => m.Id == slotBefore.Id);
                                                slotChange.Status = "3"; //改变状态（正在出库）
                                                Db.Updateable(slotChange).ExecuteCommand();

                                                #endregion
                                            }
                                        }
                                    }
                                }
                                else if (slotBefore.Status == "2" || slotBefore.Status == "4") //前面储位状态是入库中或者移入中
                                {
                                    flagList.Add(5);
                                    continue;
                                }

                                #region 添加出库任务

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

                                    StartLocat = locate.LocatNo,//起始位置
                                    EndLocat = "",//目标位置
                                    PalletNo = item.PalletNo,//托盘码
                                    IsSend = 1,//是否可再次下发
                                    IsCancel = 1,//是否可取消
                                    IsFinish = 1,//是否可完成
                                    Type = "1",//任务类型 0 入库任务 1 出库任务  2 移库任务
                                    Status = "0",//任务状态0：等待执行1正在执行2执行完成
                                    OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单
                                    Msg = locate.LocatNo + "的出库任务"
                                };
                                Db.Insertable(exTask1).ExecuteCommand();

                                outDto2.Add(new OutCommandDto()
                                {
                                    SkuType = sku.Type, //物料类型
                                    StartRoadway = locate.RoadwayNo, //起始巷道
                                    PalletNo = item.PalletNo,//托盘号
                                    StartLocat = locate.LocatNo, // 起始位置
                                    EndLocat = "", // 目标位置 
                                    TaskNo = exTask1.TaskNo, // 任务号
                                    Type = "1",// 任务类型 (出库)
                                    OutMode = "",  //目标地址
                                    Order = 1,
                                    IsBale = item.IsBale, //是否裹包
                                    IsBelt = item.IsBelt, //是否打带
                                    IsStacking1 = item.IsAdvance, //是否拆桶（08暂定）
                                    Qty = item.Qty, //拣货数量
                                    FullQty = (int)item.BoxexQty, //托盘数量
                                    PalletType = stockDetail.PalletType, //托盘类型(有无子托)0||空||null：无子托盘1：有子托盘
                                });
                                taskNoStr = exTask1.TaskNo;
                                #endregion

                            }


                            #region 改变数据
                            if (item.Status == "0")//判断托盘是否下发过
                            {
                                var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                                if (noticeDetail != null) //更新出库单据的下发数量
                                {
                                    noticeDetail.FactQty += item.Qty;
                                    noticeDetail.Status = "2";
                                    Db.Updateable(noticeDetail).ExecuteCommand();
                                }

                                //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                                if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
                                {
                                    var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
                                    if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
                                    {
                                        notice.Status = "3"; //变更状态为正在执行
                                        Db.Updateable(notice).ExecuteCommand();
                                    }
                                }
                            }
                            item.TaskNo = taskNoStr; // 出库分配信息中更新任务号
                            item.Status = "1"; // 出库分配信息状态改为正在执行 
                            Db.Updateable(item).ExecuteCommand();
                            locate.Status = "3"; //要出库的储位改变状态 正在出库
                            Db.Updateable(locate).ExecuteCommand();

                            #endregion

                            flagList.Add(0);
                        }
                        else if (locate.Status == "3") //出库中
                        {
                            if (sku.Type == "2" || sku.Type == "3")
                            {
                                continue;
                            }
                            #region 改变数据
                            //判断是否是已经出过库又回库（状态为待拣货的 1）
                            if (item.Status == "0")
                            {
                                var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                                if (noticeDetail != null) //更新出库单据的下发数量
                                {
                                    noticeDetail.FactQty += item.Qty;
                                    noticeDetail.Status = "2";
                                    Db.Updateable(noticeDetail).ExecuteCommand();
                                }

                                //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                                if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
                                {
                                    var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
                                    if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
                                    {
                                        notice.Status = "3"; //变更状态为正在执行
                                        Db.Updateable(notice).ExecuteCommand();
                                    }
                                }
                            }
                            var taskNo = Db.Queryable<LogTask>().First(m => m.OrderType == "1" && m.TaskNo != item.TaskNo && m.Status == "1" && m.PalletNo == item.PalletNo);
                            item.TaskNo = taskNo.TaskNo;
                            item.Status = "1"; // 出库分配信息状态改为正在执行 
                            Db.Updateable(item).ExecuteCommand();

                            #endregion
                        }
                        else if (locate.Status == "5") //移出中
                        {
                            flagList.Add(1);
                        }
                    }

                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", soNo, "出库", $"点击出库按钮出库单号为：{soNo}的出库单", userId);
                    Db.CommitTran();

                    //先移库后出库
                    outDto1.AddRange(moveDto);
                    outDto1.AddRange(outDto2);
                    str = string.Empty;
                    if (flagList.Count(m => m == 1) > 0)
                    {
                        str += "1.当前要出库的储位正在移出、";
                    }
                    if (flagList.Count(m => m == 2) > 0)
                    {
                        str += "2.出库的托盘储位信息错误(在储位表中未查询到)、";
                    }
                    if (flagList.Count(m => m == 3) > 0)
                    {
                        str += "4.储位损坏不能出库、";
                    }
                    if (flagList.Count(m => m == 4) > 0)
                    {
                        str += "3.要出库的托盘正在入库、";
                    }
                    if (outDto1.Count > 0)
                    {
                        // 正式运行程序放开
                        var list2 = outDto1.Select(m => m.TaskNo).ToList();
                        var jsonData = JsonConvert.SerializeObject(outDto1);
                        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.stateCode == 1)
                            {
                                //更改任务的发送返回时间//
                                new TaskServer().EditTaskIssueOk(list2, time1, time2);
                                str += "下发成功";
                            }
                            else
                            {
                                new TaskServer().EditTaskIssueNo(list2, time1, time2, wcsModel.errMsg);
                                throw new Exception(wcsModel.errMsg);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw new Exception(ex.Message);
                        }

                    }

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


                #endregion
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        #region 下发出库单深度库

        //// 下发出库单深度库（调用cs接口给他库位地址）
        //public List<OutCommandDto> IssueOutHouse(string soNo, int userId, string url, out string str)
        //{
        //    //测试url 发布服务器后删除
        //    url = "http://localhost:57061/api/WCSApi/AddTasks";

        //    try
        //    {
        //        #region 集合 

        //        var outDtoList = new List<OutCommandDto>(); //出库数据的集合 
        //        //记录错误信息的集合 
        //        var flagList = new List<int>();//1:当前要出库的储位正在移出、2 出库的托盘储位信息错误(在储位表中未查询到)、3储位损坏不能出库、4 要出库的托盘正在入库

        //        #endregion
        //        var com = new Common();
        //        //assign.IsHavePyTask();
        //        var notice = Db.Queryable<BllExportNotice>().First(m => m.SONo == soNo && m.IsDel == "0");
        //        if (notice == null)
        //        {
        //            throw new Exception($"未找到{soNo}出库单信息");
        //        }
        //        //所有要出库的出库分配信息(未下发的信息和待拣货的信息)
        //        var list = Db.Queryable<BllExportAllot>().Where(a => a.IsDel == "0" && a.SONo == soNo && (a.Status == "0" || (a.Status == "2" && a.CompleteQty == 0))).ToList();
        //        if (list.Count == 0) //判断是否有需要下发的出库流水
        //        {
        //            throw new Exception("当前出库单据无需要下发的托盘");
        //        }

        //        #region 集合 
        //        //要出库的托盘集合
        //        var outLpnList = list.Select(m => m.PalletNo).ToList();
        //        //要出库的明细集合
        //        var outStockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToList();
        //        Db.BeginTran();
        //        try
        //        {
        //            //循环判断深度1 深度2外是否有货物（有进行移库后再进行出库） 深度2 的任务优先级
        //            //循环分配的信息生成出库任务
        //            foreach (var item in list)
        //            {
        //                // 储位号
        //                var locateNo = outStockDetail.First(m => m.PalletNo == item.PalletNo).LocatNo;

        //                #region 判断

        //                //判断托盘是否在库内
        //                if (string.IsNullOrWhiteSpace(locateNo))
        //                {
        //                    //判断托盘是否在入库中
        //                    var imBl = com.GetImTask(item.PalletNo);
        //                    if (imBl != null)
        //                    {
        //                        flagList.Add(4);
        //                        continue;
        //                    }
        //                    //判断是否是已经出过库又回库（状态为待拣货的 1）
        //                    if (item.Status == "0")
        //                    {
        //                        //如果不在仓库内，当前分配信息直接更新出库完成 
        //                        item.Status = "1";//状态
        //                        item.OutMode = "1号口";//出库口 
        //                        Db.Updateable(item).ExecuteCommand();
        //                        var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
        //                        if (noticeDetail != null) //更新出库单据的下发数量
        //                        {
        //                            noticeDetail.FactQty += item.Qty;
        //                            Db.Updateable(noticeDetail).ExecuteCommand();
        //                        }

        //                        //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
        //                        if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
        //                        {
        //                            var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
        //                            if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
        //                            {
        //                                notice.Status = "3"; //变更状态为正在执行
        //                                Db.Updateable(notice).ExecuteCommand();
        //                            }
        //                        }
        //                    }
        //                    continue;
        //                }

        //                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo && m.IsDel == "0");//当前出库的储位信息
        //                if (locate == null)
        //                {
        //                    flagList.Add(2);
        //                    continue;
        //                }
        //                //判断储位标志是否为损坏
        //                if (locate.Flag == "2")
        //                {
        //                    flagList.Add(3);
        //                    continue;
        //                }

        //                #endregion

        //                if (locate.Status == "1") //有物品
        //                {
        //                    #region 添加出库任务

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

        //                        StartLocat = locate.LocatNo,//起始位置
        //                        EndLocat = "",//目标位置
        //                        PalletNo = item.PalletNo,//托盘码
        //                        IsSend = 1,//是否可再次下发
        //                        IsCancel = 1,//是否可取消
        //                        IsFinish = 1,//是否可完成
        //                        Type = "1",//任务类型 0 入库任务 1 出库任务  2 移库任务
        //                        Status = "0",//任务状态0：等待执行1正在执行2执行完成
        //                        OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单

        //                    };
        //                    Db.Insertable(exTask).ExecuteCommand();

        //                    outDtoList.Add(new OutCommandDto()
        //                    {
        //                        PalletNo = item.PalletNo,//托盘号
        //                        StartLocat = locate.LocatNo, // 起始位置
        //                        EndLocat = "", // 目标位置 
        //                        TaskNo = exTask.TaskNo, // 任务号
        //                        Type = "1",// 任务类型 (出库)
        //                        OutMode = "",  //目标地址
        //                        Order = 1
        //                    });
        //                    #endregion

        //                    #region 改变数据
        //                    if (item.Status == "0")//判断托盘是否下发过
        //                    {
        //                        var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
        //                        if (noticeDetail != null) //更新出库单据的下发数量
        //                        {
        //                            noticeDetail.FactQty += item.Qty;
        //                            Db.Updateable(noticeDetail).ExecuteCommand();
        //                        }

        //                        //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
        //                        if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
        //                        {
        //                            var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
        //                            if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
        //                            {
        //                                notice.Status = "3"; //变更状态为正在执行
        //                                Db.Updateable(notice).ExecuteCommand();
        //                            }
        //                        }
        //                    }
        //                    locate.Status = "3"; //要出库的储位改变状态 正在出库
        //                    Db.Updateable(locate).ExecuteCommand();

        //                    item.TaskNo = exTask.TaskNo; // 出库分配信息中更新任务号
        //                    item.Status = "1"; // 出库分配信息状态改为正在执行 
        //                    Db.Updateable(item).ExecuteCommand();


        //                    #endregion

        //                    flagList.Add(0);
        //                }
        //                else if (locate.Status == "3") //出库中
        //                {
        //                    #region 改变数据
        //                    //判断是否是已经出过库又回库（状态为待拣货的 1）
        //                    if (item.Status == "0")
        //                    {
        //                        var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
        //                        if (noticeDetail != null) //更新出库单据的下发数量
        //                        {
        //                            noticeDetail.FactQty += item.Qty;
        //                            Db.Updateable(noticeDetail).ExecuteCommand();
        //                        }

        //                        //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
        //                        if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
        //                        {
        //                            var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
        //                            if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
        //                            {
        //                                notice.Status = "3"; //变更状态为正在执行
        //                                Db.Updateable(notice).ExecuteCommand();
        //                            }
        //                        }
        //                    }
        //                    var taskNo = Db.Queryable<LogTask>().First(m => m.OrderType == "1" && m.TaskNo != item.TaskNo && m.Status == "1" && m.PalletNo == item.PalletNo);
        //                    item.TaskNo = taskNo.TaskNo;
        //                    item.Status = "1"; // 出库分配信息状态改为正在执行 
        //                    Db.Updateable(item).ExecuteCommand();

        //                    #endregion
        //                }
        //                else if (locate.Status == "5") //移出中
        //                {
        //                    flagList.Add(1);
        //                }
        //            }

        //            //添加操作日志记录
        //            var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", soNo, "出库", $"点击出库按钮出库单号为：{soNo}的出库单", userId);
        //            Db.CommitTran();

        //            str = string.Empty;
        //            if (flagList.Count(m => m == 1) > 0)
        //            {
        //                str += "1.当前要出库的储位正在移出、";
        //            }
        //            if (flagList.Count(m => m == 2) > 0)
        //            {
        //                str += "2.出库的托盘储位信息错误(在储位表中未查询到)、";
        //            }
        //            if (flagList.Count(m => m == 3) > 0)
        //            {
        //                str += "4.储位损坏不能出库、";
        //            }
        //            if (flagList.Count(m => m == 4) > 0)
        //            {
        //                str += "3.要出库的托盘正在入库、";
        //            }
        //            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.stateCode == 0)
        //                    {
        //                        //更改任务的发送返回时间//
        //                        new TaskServer().EditTaskIssueOk(list2, time1, time2);
        //                        str += "下发成功";
        //                    }
        //                    else
        //                    {
        //                        new TaskServer().EditTaskIssueNo(list2, time1, time2, wcsModel.errMsg);
        //                        throw new Exception(wcsModel.errMsg);
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    throw new Exception(ex.Message);
        //                }

        //            }

        //            return outDtoList;
        //        }
        //        catch (Exception e)
        //        {
        //            Db.RollbackTran();
        //            throw new Exception(e.Message);
        //        }


        //        #endregion
        //    }
        //    catch (Exception e)
        //    {
        //        throw new Exception(e.Message);
        //    }
        //}

        #endregion

        //wcs返回的成功信号（出库成功）
        public void ExportSuccess(string taskNo, int userId, string url)
        {
            try
            {
                //当前任务信息
                var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
                if (task == null)
                {
                    throw new Exception($"未查询到任务号为：‘{taskNo}’的任务信息");
                }
                if (task.Status == "2")
                {
                    throw new Exception("当前任务已完成");
                }
                Db.BeginTran();
                //库存中当前托盘的信息
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo && m.IsDel == "0").ToList();
                var locateNo = stockDetail.Select(m => m.LocatNo).Distinct().FirstOrDefault();
                string skunno = "";
                BllBoxInfo bind = new BllBoxInfo();
                if (stockDetail.Count <= 0)
                {
                    string str = $"select Top 1 * from BllBoxInfo where IsDel = '0' and PalletNo = '{task.PalletNo}' order by CreateTime desc";
                    bind = Db.Ado.SqlQuerySingle<BllBoxInfo>(str);
                    skunno = bind.SkuNo;
                }
                else if (stockDetail.Count > 0)
                {
                    skunno = stockDetail[0].SkuNo;
                }
                //当前任务中的储位信息
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo);
                //获取对应物料当天库存信息
                string strinfo = $"select top 1 * from DataStockInfo where IsDel = '0' and SkuNo = '{skunno}' order by CreateTime desc";
                var datainfo = Db.Ado.SqlQuerySingle<DataStockInfo>(strinfo);
                try
                {
                    task.Status = "2";//任务状态
                    task.IsSend = 0;
                    task.IsCancel = 0;
                    task.IsFinish = 0;
                    task.FinishDate = DateTime.Now;//完成时间
                    Db.Updateable(task).ExecuteCommand();
                    locate.Status = "0"; // 更改当前任务中的储位状态（改为0空储位）
                    Db.Updateable(locate).ExecuteCommand();

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

                            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();
                                }
                            }

                            #region 库存记录

                            //datainfo.ArrivalQty += 0;//入库数量
                            datainfo.ExportQty += item.LockQty.Value;//出库数量
                            datainfo.BalanceQty -= item.LockQty.Value;//结存数量
                            datainfo.YearBalanceQty -= item.LockQty.Value;//结存数量(月)
                            datainfo.YearExportQty += item.LockQty.Value;//出库数量（月）
                            Db.Updateable(datainfo).ExecuteCommand();

                            #endregion




                            //获取库存箱码信息
                            var stockBox = Db.Queryable<DataBoxInfo>().Where(m => m.StockDetailId == item.Id).ToList();
                            Db.Deleteable(stockBox).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;
                        }
                        var allots = Db.Queryable<BllExportAllot>().First(m => m.IsDel == "0" && (m.TaskNo == taskNo || (m.Status == "1" && m.PalletNo == task.PalletNo)));
                        if (allots == null)//判断是否为空（控制出库时移库没有库位出库的情况）
                        {
                            item.LocatNo = "";//储位更改（改为空）
                            item.WareHouseNo = "";//所属仓库更改（改为空）
                            item.RoadwayNo = "";//所属巷道更改（改为空）
                            item.AreaNo = "";//所属区域更改（改为空）
                            Db.Updateable(item).ExecuteCommand();
                            continue;
                        }
                        var soDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.Id == allots.SODetailNo && m.IsDel == "0");
                        var so = Db.Queryable<BllExportNotice>().First(m => m.SONo == soDetail.SONo && m.IsDel == "0");
                        if (so.Type == "4") //判断单据类型是否是质检取样出库
                        {
                            item.LocatNo = "";//储位更改（改为空）
                            item.WareHouseNo = "";//所属仓库更改（改为空）
                            item.RoadwayNo = "";//所属巷道更改（改为空）
                            item.AreaNo = "";//所属区域更改（改为空）
                            Db.Updateable(item).ExecuteCommand();
                            continue;
                        }
                        //如果是桶装质检拣货 1.根据物料判断当前物料是否是罐装桶类（不管材质 铁桶、塑料桶）
                        var sku = Db.Queryable<SysMaterials>().First(m => m.SkuNo == item.SkuNo && m.IsDel == "0");
                        if (sku.Type == "0" || sku.Type == "2" || sku.Type == "3" || sku.Type == "4" || sku.Type == "8")//如果是桶或吨袋类型的走拣货流程 以及其它类型
                        {
                            //根据流水查询到需拣货多少数量，修改库存表、库存明细表（参考上面空托出库源代码）
                            var allotInfo = Db.Queryable<BllExportAllot>().First(m => m.IsDel == "0" && m.StockId == item.Id && (m.TaskNo == taskNo || m.Status == "1"));
                            //判断总库存是否为0，如果为0删除 否则减去数量
                            var stock = Db.Queryable<DataStock>().First(m => m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.IsDel == "0");
                            var stockBox = Db.Queryable<DataBoxInfo>().Where(m => m.StockDetailId == item.Id && m.IsDel == "0").ToList();
                            if (stock != null)
                            {
                                stock.Qty -= allotInfo.Qty;
                                stock.LockQty -= allotInfo.Qty;

                                if (stock.Qty == 0)
                                {
                                    Db.Deleteable(stock).ExecuteCommand();
                                }
                                else
                                {
                                    Db.Updateable(stock).ExecuteCommand();
                                }
                            }
                            item.Qty -= allotInfo.Qty;
                            item.LockQty -= allotInfo.Qty;
                            foreach (var info in stockBox)
                            {
                                info.Qty -= allotInfo.Qty;
                                if (info.Qty == 0)
                                {
                                    Db.Deleteable(info).ExecuteCommand();
                                }
                                else
                                {
                                    Db.Updateable(info).ExecuteCommand();
                                }
                            }

                            #region 库存记录

                            //datainfo.ArrivalQty += 0;//入库数量
                            datainfo.ExportQty += allotInfo.Qty;//出库数量
                            datainfo.BalanceQty -= allotInfo.Qty;//结存数量
                            datainfo.YearBalanceQty -= allotInfo.Qty;//结存数量(月)
                            datainfo.YearExportQty += allotInfo.Qty;//出库数量（月）
                            Db.Updateable(datainfo).ExecuteCommand();

                            #endregion


                            //continue;
                        }
                        if (item.Qty == 0)
                        {
                            Db.Deleteable(item).ExecuteCommand();
                            //托盘状态改为未使用
                            var sCode = Db.Queryable<SysPallets>().First(m => m.PalletNo == item.PalletNo && m.IsDel == "0");
                            if (sCode != null)
                            {
                                sCode.Status = "0";
                                Db.Updateable(sCode).ExecuteCommand();
                            }
                        }
                        else
                        {
                            item.LocatNo = "";//储位更改（改为空）
                            item.WareHouseNo = "";//所属仓库更改（改为空）
                            item.RoadwayNo = "";//所属巷道更改（改为空）
                            item.AreaNo = "";//所属区域更改（改为空）
                            item.Status = "0"; //分配状态（改为待分配）
                            Db.Updateable(item).ExecuteCommand();
                        }

                    }
                    //如果是桶装质检拣货
                    //更改出库分配流水及单据数量、状态等信息

                    //出库流水（更改状态）
                    var allot = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && (m.TaskNo == taskNo || (m.Status == "1" && m.PalletNo == task.PalletNo) && m.IsDel == "0")).ToList();

                    foreach (var item in allot)
                    {
                        if (item.SkuNo == "100099" || item.SkuNo == "100098" || item.SkuNo == "100097" || item.SkuNo == "100096" || item.SkuNo == "100095")
                        {
                            item.CompleteQty = item.Qty;
                            item.Status = "5";
                            continue;
                        }
                        var soDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.Id == item.SODetailNo && m.IsDel == "0");

                        var sku = Db.Queryable<SysMaterials>().First(m => m.SkuNo == soDetail.SkuNo && m.IsDel == "0");
                        var so = Db.Queryable<BllExportNotice>().First(m => m.SONo == soDetail.SONo && m.IsDel == "0");
                        if (so.Type == "4")//判断单据类型是否是质检取样出库
                        {
                            item.Status = "2";
                            continue;
                        }
                        if (sku.Type == "0" || sku.Type == "2" || sku.Type == "3" || sku.Type == "4" || sku.Type == "8") //如果是桶或吨袋类型的走拣货流程
                        {
                            item.Status = "5";//不是4就是5待定 4：待回库，5：已完成
                            item.CompleteQty = item.Qty;//拣货数量
                            //添加拣货明细
                            var completeDetail = new BllCompleteDetail()
                            {
                                SONo = item.SONo,
                                SODetailNo = soDetail.Id,
                                ExportAllotId = item.Id,
                                StockId = item.StockId,
                                BoxNo = "",
                                BoxNo2 = "",
                                BoxNo3 = "",

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

                                CreateUser = userId
                            };
                            Db.Insertable(completeDetail).ExecuteCommand();

                            soDetail.CompleteQty += item.Qty;
                            if (soDetail.CompleteQty == soDetail.Qty)
                            {
                                soDetail.Status = "3";
                            }
                            Db.Updateable(soDetail).ExecuteCommand();

                            var num = Db.Queryable<BllExportNoticeDetail>().Count(m => m.Status != "3" && m.IsDel == "0" && m.SONo == so.SONo);
                            if (num == 0)
                            {

                                so.Status = "4";
                                Db.Updateable(so).ExecuteCommand();
                            }


                        }
                        else
                        {
                            item.Status = "2";
                        }
                    }
                    Db.Updateable(allot).ExecuteCommand();

                    if (userId != 0)
                    {
                        //添加操作日志记录
                        var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);

                        // 正式运行程序放开
                        var jsonData = JsonConvert.SerializeObject(task);
                        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);
                        }
                        catch (Exception ex)
                        {
                            Db.RollbackTran();
                            throw new Exception(ex.Message);
                        }

                    }
                    Db.CommitTran();
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("完成反馈失败：" + ex.Message);
            }
        }

        //重新下发出库任务
        public OutCommandDto AgainSendSoTask(string taskNo, int userId, string url)
        {
            try
            {
                var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
                if (task == null)
                {
                    throw new Exception("未查询到任务信息");
                }
                var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.PalletNo == task.PalletNo);
                if (stockDetail == null)
                {
                    throw new Exception(task.PalletNo + " 当前托盘未在库内，请核实信息");
                }
                Db.BeginTran();
                var locateNo = task.StartLocat;
                //判断任务中起始位置是否和库存中位置一致
                if (task.StartLocat != stockDetail.LocatNo)
                {
                    locateNo = stockDetail.LocatNo;
                    task.StartLocat = locateNo;
                    Db.Updateable(task).ExecuteCommand();
                }
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo);
                if (locate != null && locate.Status != "3")
                {
                    locate.Status = "3";
                    Db.Updateable(locate).ExecuteCommand();
                }
                var outDto = new OutCommandDto()
                {
                    PalletNo = task.PalletNo,//托盘号
                    StartLocat = locateNo, // 起始位置
                    EndLocat = task.EndLocat, // 目标位置 
                    TaskNo = task.TaskNo, // 任务号
                    Type = task.Type,// 任务类型 (出库)
                    OutMode = "",  //目标地址
                    Order = 1
                }; //出库数据 
                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库日志", taskNo, "下发", $"点击下发按钮、重新下发了任务号为：{taskNo}的任务", (int)userId);
                Db.CommitTran();
                // 正式运行程序放开
                var list = new List<string> { outDto.TaskNo };
                var jsonData = JsonConvert.SerializeObject(outDto);

                try
                {
                    var time1 = DateTime.Now;//发送时间 .ToString("yyyy-MM-dd HH:mm:ss")
                    var 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.stateCode == 1)
                    {
                        //更改任务的发送返回时间//
                        new TaskServer().EditTaskIssueOk(list, time1, time2);
                    }
                    else
                    {
                        new TaskServer().EditTaskIssueNo(list, time1, time2, wcsModel.errMsg);
                        throw new Exception($"wcs返回状态异常：{wcsModel.errMsg}");
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
                return outDto;
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw new Exception(e.Message);
            }
        }

        //取消出库任务
        public void CancelSoTask(string taskNo, int userId, string url)
        {
            try
            {
                Db.BeginTran();
                try
                {
                    var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
                    if (task == null)
                    {
                        throw new Exception("未查询到任务信息");
                    }
                    //获取对应库位信息
                    var startlocat = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.WareHouseNo == "W03" && a.LocatNo == task.StartLocat);
                    if (startlocat == null)
                    {
                        throw new Exception("未查询到储位信息");
                    }
                    //获取移库任务对应目标储位信息
                    SysStorageLocat endlocat = new SysStorageLocat();
                    if (task.Type == "2")
                    {
                        endlocat = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.WareHouseNo == "W03" && a.LocatNo == task.EndLocat);
                        if (endlocat == null)
                        {
                            throw new Exception("未查询到目标储位信息");
                        }
                    }
                    if (startlocat == null)
                    {
                        Db.RollbackTran();
                        throw new Exception("未查询到储位信息，请核实！");
                    }
                    //修改储位信息
                    startlocat.Status = "1"; //有物品 1
                    Db.Updateable(startlocat).ExecuteCommand();
                    if (endlocat != null)
                    {
                        endlocat.Status = "0"; //空储位 0
                        Db.Updateable(endlocat).ExecuteCommand();
                    }
                    //修改任务 
                    task.IsSuccess = 1;
                    task.IsCancel = 0;
                    task.IsFinish = 0;
                    task.Status = "3";
                    task.CancelDate = DateTime.Now;
                    Db.Updateable(task).ExecuteCommand();

                    //出库分配信息
                    var allot = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.TaskNo == taskNo).ToList();
                    foreach (var item in allot)
                    {
                        item.Status = "0";//修改分配信息状态
                        item.TaskNo = "";
                        var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                        if (noticeDetail != null)
                        {
                            //throw new Exception("未查询到出库单明细信息");


                            noticeDetail.FactQty -= item.Qty; //修改出库单明细的下架数量
                            Db.Updateable(noticeDetail).ExecuteCommand();
                            if (noticeDetail.FactQty == 0)
                            {
                                var noticeDetail2 = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo && m.Id != noticeDetail.Id).ToList();
                                var num = noticeDetail2.Count(m => m.FactQty > 0);
                                //判断出库单的所有明细是否都为0；如果为0变更出库单状态为已分配
                                if (num == 0)
                                {
                                    var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                                    notice.Status = "2";
                                    Db.Updateable(notice).ExecuteCommand();
                                }
                            }
                        }
                    }
                    Db.Updateable(allot).ExecuteCommand();
                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库日志", taskNo, "取消", $"点击取消按钮、取消了任务号为：{taskNo}的任务", (int)userId);

                    // 正式运行程序放开
                    var jsonData = JsonConvert.SerializeObject(task);
                    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);
                    }
                    catch (Exception ex)
                    {
                        Db.RollbackTran();
                        throw new Exception(ex.Message);
                    }

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

        /// <summary>
        /// wcs返回的成功信号（移库成功）
        /// </summary>
        /// <param name="taskNo">任务号</param>
        /// <param name="userId">操作人</param>
        /// <exception cref="Exception"></exception>
        public void RelocationSuccess(string taskNo, int userId, string url)
        {
            try
            {
                //当前任务信息
                var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
                if (task == null)
                {
                    throw new Exception($"未查询到任务号为：‘{taskNo}’的任务信息");
                }
                if (task.Status == "2")
                {
                    throw new Exception("当前任务已完成");
                }
                Db.BeginTran();
                //库存中当前托盘的信息
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
                //当前任务中的目标储位信息
                //当前任务中的原储位
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.StartLocat);
                if (locate == null)
                {
                    throw new Exception($"WMS系统中没有该{task.StartLocat}储位对应的信息");
                }
                var locate2 = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
                if (locate2 == null)
                {
                    throw new Exception($"WMS系统中没有该{task.EndLocat}储位对应的信息");
                }

                try
                {
                    task.Status = "2";//任务状态
                    task.IsSend = 0;
                    task.IsCancel = 0;
                    task.IsFinish = 0;
                    task.FinishDate = DateTime.Now;//完成时间
                    Db.Updateable(task).ExecuteCommand();

                    #region 修改储位状态

                    //原储位改为空储位 0
                    locate.Status = "0";
                    Db.Updateable(locate).ExecuteCommand();

                    //目标储位改为有货物 1
                    locate2.Status = "1";
                    Db.Updateable(locate2).ExecuteCommand();
                    foreach (var item in stockDetail)
                    {
                        item.LocatNo = locate2.LocatNo;
                    }
                    Db.Updateable(stockDetail).ExecuteCommand();

                    #endregion

                    if (userId != 0)
                    {
                        //添加操作日志记录
                        var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);

                        // 正式运行程序放开
                        var jsonData = JsonConvert.SerializeObject(task);
                        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);
                        }
                        catch (Exception ex)
                        {
                            Db.RollbackTran();
                            throw new Exception(ex.Message);
                        }

                    }
                    Db.CommitTran();
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("完成反馈失败：" + ex.Message);
            }
        }

        #endregion

        #region 出库分配

        //自动分配
        public bool AutoAllot(string soNo, int userId)
        {
            try
            {
                #region 判断条件（出库单、出库单明细） 
                //出库单
                var notice = Db.Queryable<BllExportNotice>().Where(m => m.IsDel == "0" && m.SONo == soNo).ToList().FirstOrDefault();
                if (notice == null)
                {
                    throw new Exception("未查询到出库单据信息");
                }
                if (notice.Status != "0" && notice.Status != "1")
                {
                    throw new Exception("参数异常,请检查状态是否为等待执行或部分分配或来源是否是WMS");
                }
                //出库单明细
                var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == soNo && (m.AllotQty - m.Qty) <= 0).ToList();
                if (!detailList.Any())
                {
                    throw new Exception("未查询到符合分配条件的出库单据明细信息");
                }

                #endregion

                //包装信息
                var packageNos = detailList.Select(d => d.PackagNo).ToList();
                var packList = Db.Queryable<SysPackag>().Where(m => packageNos.Contains(m.PackagNo)).ToList();

                var exAllotList = new List<BllExportAllot>();
                var assign = new AllotSku();
                Db.BeginTran();
                try
                {
                    foreach (var detail in detailList)
                    {

                        if (detail.AllotQty >= detail.Qty)
                        {
                            continue;
                        }
                        //还需要分配的数量
                        var needQty = detail.Qty - detail.AllotQty;
                        //库存明细 Status 0：待分配 1：部分分配  2：已分配 
                        var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.SkuNo == detail.SkuNo && (m.Qty - m.FrozenQty - m.LockQty - m.InspectQty) > 0 && (m.Status == "0" || m.Status == "1") && m.IsDel == "0").ToList();


                        //判断单号是否指定批次
                        if (!string.IsNullOrWhiteSpace(detail.LotNo))
                        {
                            stockDetail = stockDetail.Where(m => m.SkuNo == detail.SkuNo && m.LotNo == detail.LotNo && m.IsDel == "0").ToList();
                        }
                        else
                        {
                            stockDetail = stockDetail.Where(m => m.SkuNo == detail.SkuNo && string.IsNullOrWhiteSpace(m.LotNo) && m.IsDel == "0").ToList();
                        }

                        if (stockDetail.Count < 1)
                        {
                            throw new Exception("库存不足,无可出库库存");
                        }

                        if (notice.Type == "0" || notice.Type == "1")//成品、原辅料出库
                        {
                            stockDetail = stockDetail.Where(m => m.InspectStatus == "1").ToList();
                        }
                        else if (notice.Type == "2" || notice.Type == "3")//成品、原辅料出库(不合格)
                        {
                            stockDetail = stockDetail.Where(m => m.InspectStatus == "2").ToList();
                        }
                        else if (notice.Type == "4")//取样出库
                        {
                            stockDetail = stockDetail.Where(m => m.InspectStatus == "0").ToList();
                        }
                        //将库存明细按深度进行排序 深度1在前 深度2在后
                        //stockDetail = stockDetail.OrderBy(d => int.Parse(d.LocatNo.Substring(6, 2))).ToList();
                        #region 包装信息

                        var pack = packList.FirstOrDefault(p => p.PackagNo == detail.PackagNo);
                        if (pack == null)
                        {
                            throw new Exception("未查询到物料包装");
                        }
                        var pNum = 0;//托盘物品数量
                        var bNum = 0;//箱物品数量
                        if (pack.L5Num.HasValue)
                        {
                            pNum = Convert.ToInt32(pack.L5Num);
                            bNum = Convert.ToInt32(pack.L4Num);
                        }
                        else if (pack.L4Num.HasValue)
                        {
                            pNum = Convert.ToInt32(pack.L4Num);
                            bNum = Convert.ToInt32(pack.L3Num);
                        }
                        else if (pack.L3Num.HasValue)
                        {
                            pNum = Convert.ToInt32(pack.L3Num);
                            bNum = Convert.ToInt32(pack.L2Num);
                        }
                        else if (pack.L2Num.HasValue)
                        {
                            pNum = Convert.ToInt32(pack.L2Num);
                            bNum = Convert.ToInt32(pack.L1Num);
                        }
                        else if (pack.L1Num.HasValue)
                        {
                            pNum = Convert.ToInt32(pack.L1Num);
                            bNum = Convert.ToInt32(pack.L1Num);
                        }
                        if (pNum == 0)
                        {
                            throw new Exception("未查询到物料包装托箱关系信息");
                        }
                        #endregion
                        //取合适库存商品
                        Dictionary<int, int> stockQtyDic = new Dictionary<int, int>();//托出库物品数
                        Dictionary<string, int> zxQtyDic = new Dictionary<string, int>();//托出整箱数
                        //分配货物
                        //assign.AllocatePallets(stocks, pNum, bNum, needQty, stockQtyDic, zxQtyDic);
                        int qty = assign.AllotPallets(stockDetail, int.Parse(needQty.ToString()), pNum, bNum, stockQtyDic);

                        foreach (var sc in stockQtyDic)
                        {
                            var s = stockDetail.FirstOrDefault(m => m.Id == sc.Key);
                            //添加分配表信息
                            var allot = new BllExportAllot
                            {
                                SONo = notice.SONo,
                                WaveNo = "",
                                SODetailNo = detail.Id,
                                StockId = sc.Key,
                                LotNo = s.LotNo,
                                LotText = s.LotText,
                                SupplierLot = s.SupplierLot,
                                SkuNo = s.SkuNo,
                                SkuName = s.SkuName,
                                Standard = s.Standard,
                                PalletNo = s.PalletNo,
                                IsBale = detail.IsBale == "0" ? "0" : s.IsBale == "1" ? "0" : "1", //是否裹包
                                IsBelt = detail.IsBelt == "0" ? "0" : s.IsBelt == "1" ? "0" : "1", //是否打带

                                Qty = sc.Value,
                                CompleteQty = 0,
                                BoxexQty = s.Qty, //箱内数量
                                Status = "0",
                                LogisticsId = notice.LogisticsId,
                                //IsAdvance = s.IsBale != "0" || s.IsBelt != "0" ? "0" : detail.IsBale != "0" || detail.IsBelt != "0" ? "0" : detail.IsWave, //08暂定是否拆桶
                                IsAdvance = detail.IsWave == "1" ? detail.IsWave : s.IsBale != "0" || s.IsBelt != "0" ? "1" : detail.IsBale != "0" || detail.IsBelt != "0" ? "1" : string.IsNullOrWhiteSpace(detail.IsWave) ? "1" : detail.IsWave, //08暂定是否拆桶
                                OutMode = "",//出库口
                                CreateUser = userId,
                                CreateTime = DateTime.Now
                            };
                            exAllotList.Add(allot);

                            s.LockQty += stockQtyDic[s.Id];

                            if (s.LockQty == s.Qty)
                            {
                                s.Status = "2";
                            }
                            else
                            {
                                s.Status = "1";
                            }

                            var sd = Db.Updateable(s).UpdateColumns(it => new { it.LockQty, it.Status }).ExecuteCommand();
                        }
                        detail.AllotQty += qty;
                        detail.UpdateUser = userId;
                        detail.UpdateTime = DateTime.Now;
                        if (detail.Status == "0")
                        {
                            detail.Status = "1";
                        }

                        //库存总表
                        var stock = Db.Queryable<DataStock>().First(d => d.IsDel == "0" && d.SkuNo == detail.SkuNo && d.LotNo == detail.LotNo);
                        stock.LockQty += qty;
                        Db.Updateable(stock).ExecuteCommand();
                    }

                    var mx = Db.Updateable(detailList).ExecuteCommand();
                    var fp = Db.Insertable(exAllotList).ExecuteCommand();

                    //修改分配单据的状态
                    if (notice.Status == "0" || notice.Status == "1")
                    {
                        var bl = 0;
                        var bl2 = 0;
                        foreach (var item in detailList)
                        {
                            if (item.AllotQty <= 0)
                            {
                                continue;
                            }
                            if (item.AllotQty < item.Qty)
                            {
                                bl = 1;
                            }
                            else
                            {
                                bl2 = 1;
                            }
                        }

                        switch (bl2)
                        {
                            case 1 when bl == 1:
                                notice.Status = "1";//证明部分分配数量全部大于等于出库数量  修改为已分配
                                break;
                            case 0 when bl == 1:
                                notice.Status = "1";//证明部分分配数量全部大于等于出库数量  修改为已分配
                                break;
                            case 1 when bl == 0:
                                notice.Status = "2";//证明分配数量全部大于等于出库数量  修改为已分配
                                break;
                            case 0 when bl == 0:
                                //证明所有分配数量全部小于等于出库数量 不做修改
                                break;
                        }

                    }
                    notice.UpdateUser = userId;
                    notice.UpdateTime = DateTime.Now;
                    var zd = Db.Updateable(notice).ExecuteCommand();

                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", notice.SONo, "分配", $"自动分配了单据号为{notice.SONo}的单据信息", userId);

                    if (zd > 0 && mx > 0 && fp > 0 && k)
                    {
                        Db.CommitTran();
                        return true;
                    }
                    Db.RollbackTran();
                    return false;
                }
                catch (Exception e)
                {
                    Db.RollbackTran();
                    throw new Exception(e.Message);
                }
            }
            catch (Exception e)
            {
                throw new Exception("自动分配失败：" + e.Message);
            }
        }

        //取消分配
        public bool CancelAllot(string soNo, int userId)
        {
            try
            {

                var notice = Db.Queryable<BllExportNotice>().Where(m => m.IsDel == "0" && m.SONo == soNo).ToList().FirstOrDefault();
                if (notice == null)
                {
                    throw new Exception("未查询到出库单据信息");
                }
                if (notice.Status != "1" && notice.Status != "2")
                {
                    throw new Exception("参数异常,请检查状态是否为已分配或部分分配或来源是否是WMS");
                }
                //该单据的分配信息 Status 0：任务下发 1：待拣货 2：部分拣货 3：待回库 4：已完成
                var allotList = Db.Queryable<BllExportAllot>().Where(o => o.IsDel == "0" && o.SONo == soNo).ToList();
                //有已执行的分配数据不能取消
                if (allotList.Any(o => o.Status != "0"))
                {
                    throw new Exception("当前单据的分配信息已有执行中，不能取消分配");
                }
                Db.BeginTran();
                try
                {
                    //查询分配的明细
                    var detail = Db.Queryable<BllExportNoticeDetail>().Where(d => d.SONo == soNo && d.AllotQty > 0 && d.IsDel == "0").ToList();
                    foreach (var d in detail)
                    {
                        var orders = allotList.Where(o => o.SODetailNo == d.Id).ToList();
                        foreach (var o in orders)
                        {
                            var pq = Db.Queryable<DataStockDetail>().Where(t => t.Id == o.StockId);

                            var pq2 = !string.IsNullOrWhiteSpace(o.LotNo) ? pq.Where(t => t.LotNo == o.LotNo).ToList() : pq.Where(t => string.IsNullOrWhiteSpace(t.LotNo)).ToList();

                            var pallet = pq2.FirstOrDefault();
                            if (pallet != null)
                            {
                                pallet.LockQty -= o.Qty;
                                pallet.Status = pallet.LockQty == 0 ? "0" : "1"; //如果锁定数量是0状态变更为待分配 否则为部分分配
                                Db.Updateable(pallet).ExecuteCommand();

                                var stock = Db.Queryable<DataStock>().First(t => t.SkuNo == pallet.SkuNo && t.LotNo == pallet.LotNo && t.IsDel == "0");
                                stock.LockQty -= o.Qty;
                                Db.Updateable(stock).ExecuteCommand();
                            }

                        }
                        Db.Deleteable<BllExportAllot>(orders).ExecuteCommand();
                        d.AllotQty = 0;
                        d.Status = "0";
                        d.UpdateUser = userId;
                        d.UpdateTime = DateTime.Now;
                    }
                    notice.Status = "0";
                    notice.UpdateUser = userId;
                    notice.UpdateTime = DateTime.Now;
                    Db.Updateable(detail).ExecuteCommand();
                    Db.Updateable(notice).ExecuteCommand();
                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", notice.SONo, "取消分配", $"取消分配了单据号为{notice.SONo}的单据信息", userId);
                    Db.CommitTran();
                }
                catch (Exception e)
                {
                    Db.RollbackTran();
                    throw new Exception(e.Message);
                }
                return true;
            }
            catch (Exception e)
            {
                throw new Exception("取消分配失败" + e.Message);
            }
        }

        //获取库存明细信息（出库单手动分配选择数据源）
        public List<StockDetailDto> GetHandOutList(int detailId, string houseNo, string roadwayNo, string locateNo, string msg, string palletNo)
        {
            try
            {
                var detail = Db.Queryable<BllExportNoticeDetail>().First(d => d.Id == detailId);
                var roadway = Db.Queryable<SysStorageRoadway>().Where(a => a.IsDel == "0" && a.WareHouseNo == "W03" && a.Status == "0").Select(a => a.RoadwayNo).ToList();
                #region 判断条件

                if (detail == null)
                {
                    throw new Exception("获取失败，未找到指定出库单！");
                }
                if (detail.Status != "0")
                {
                    throw new Exception("获取失败，出库单状态不是等待执行！");
                }
                if (detail.AllotQty >= detail.Qty)
                {
                    throw new Exception("获取失败，出库单已分配完成!");
                }
                var notice = Db.Queryable<BllExportNotice>().First(a => a.SONo == detail.SONo);
                if (notice == null)
                {
                    throw new Exception("获取失败，未找到指定出库单!");
                }
                if (notice.Status == "3" || notice.Status == "4" || notice.Status == "5")
                {
                    throw new Exception("获取失败，出库单状态不允许!");
                }

                //if (roadway.Count == 0)
                //{
                //    throw new Exception("获取失败，当前巷道已被全部禁用!");
                //}
                #endregion

                Expression<Func<DataStockDetail, bool>> item = Expressionable.Create<DataStockDetail>()
                    .AndIF(!string.IsNullOrWhiteSpace(houseNo), m => m.WareHouseNo == houseNo)
                    .AndIF(!string.IsNullOrWhiteSpace(roadwayNo), m => m.RoadwayNo == roadwayNo)
                    .AndIF(!string.IsNullOrWhiteSpace(locateNo), m => m.LocatNo == locateNo)
                    .AndIF(!string.IsNullOrWhiteSpace(palletNo), m => m.PalletNo == palletNo)
                    .AndIF(roadway.Count > 0, m => roadway.Contains(m.RoadwayNo) || string.IsNullOrWhiteSpace(m.RoadwayNo))
                    .AndIF(roadway.Count == 0, m => string.IsNullOrWhiteSpace(m.RoadwayNo))
                    .AndIF(!string.IsNullOrWhiteSpace(msg),
                        m => m.SkuNo.Contains(msg.Trim())
                             || m.SkuName.Contains(msg.Trim())
                             || m.LocatNo.Contains(msg.Trim()))
                    .And(m => m.IsDel == "0" && m.SkuNo == detail.SkuNo && m.LotNo == detail.LotNo && m.Status == "0")
                    .ToExpression();//注意 这一句 不能少

                var list = Db.Queryable<DataStockDetail>().Where(item).Select(a => new StockDetailDto
                {
                    Id = a.Id,
                    SkuNo = a.SkuNo,
                    SkuName = a.SkuName,
                    Standard = a.Standard,
                    LotNo = a.LotNo,
                    LotText = a.LotText,
                    SupplierLot = a.SupplierLot,
                    Qty = a.Qty,
                    LocatNo = a.LocatNo,
                    RoadwayNo = a.RoadwayNo,
                    PalletNo = a.PalletNo,
                    Demo = a.Demo
                }).ToList();

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

        //手动分配出库单明细
        public void AddHandOutAllot(AddHandOutVm model, int userId)
        {
            try
            {
                #region 判断条件
                //数据验证
                var detail = Db.Queryable<BllExportNoticeDetail>().First(a => a.IsDel == "0" && a.Id == model.Id);
                if (detail == null)
                {
                    throw new Exception("操作失败，未找到指定出库单详情！");
                }
                if (detail.AllotQty >= detail.Qty || detail.Status != "0")
                {
                    throw new Exception("操作失败，出库单已分配完成！");
                }
                var notice = Db.Queryable<BllExportNotice>().First(a => a.IsDel == "0" && a.SONo == detail.SONo);
                if (notice == null)
                {
                    throw new Exception("操作失败，未找到指定出库单！");
                }
                if (notice.Status == "3" || notice.Status == "4" || notice.Status == "5")
                {
                    throw new Exception("操作失败，出库单已分配完成！");
                }
                #endregion

                //单据明细需要的出库数量
                var needQty = detail.Qty - detail.AllotQty;
                //分配的出库数量
                var outQty = model.StockList.Select(s => s.Qty).ToList().Sum();
                if (outQty != needQty)
                {
                    throw new Exception("操作失败，出库数量与计划数量不一致！");
                }
                var stockIds = model.StockList.Select(a => a.StockId).ToList();
                //库存明细
                var stockList = Db.Queryable<DataStockDetail>().Where(a => stockIds.Contains(a.Id)).ToList();

                var allotList = new List<BllExportAllot>();
                var outQtys = 0;
                foreach (var st in model.StockList)
                {
                    var stock = stockList.First(a => a.Id == st.StockId);
                    if (stock == null)
                    {
                        throw new Exception("操作失败，部分储位库存异常！");
                    }
                    if (st.Qty > (stock.Qty - stock.LockQty - stock.FrozenQty - stock.InspectQty))
                    {
                        throw new Exception("操作失败，出库数量超出库存数量！");
                    }
                    //添加分配表信息
                    var allot = new BllExportAllot
                    {
                        SONo = notice.SONo,
                        WaveNo = "",
                        SODetailNo = detail.Id,
                        StockId = st.StockId,
                        LotNo = stock.LotNo,
                        LotText = stock.LotText,
                        SupplierLot = stock.SupplierLot,
                        SkuNo = stock.SkuNo,
                        SkuName = stock.SkuName,
                        Standard = stock.Standard,
                        PalletNo = stock.PalletNo,

                        IsBale = detail.IsBale == "0" ? "0" : stock.IsBale == "1" ? "0" : "1", //是否裹包
                        IsBelt = detail.IsBelt == "0" ? "0" : stock.IsBelt == "1" ? "0" : "1", //是否打带

                        Qty = st.Qty,
                        CompleteQty = 0,
                        BoxexQty = stock.Qty, //箱内数量
                        Status = "0",
                        LogisticsId = notice.LogisticsId,
                        IsAdvance = detail.IsWave == "1" ? detail.IsWave : stock.IsBale != "0" || stock.IsBelt != "0" ? "1" : detail.IsBale != "0" || detail.IsBelt != "0" ? "1" : string.IsNullOrWhiteSpace(detail.IsWave) ? "1" : detail.IsWave, //08暂定是否拆桶
                        OutMode = "",//出库口

                        CreateUser = userId,
                        CreateTime = DateTime.Now
                    };
                    allotList.Add(allot);
                    //库存明细
                    stock.LockQty += st.Qty;
                    stock.Status = stock.LockQty == stock.Qty ? "2" : "1";

                    Db.Updateable(stock).UpdateColumns(it => new { it.LockQty }).ExecuteCommand();
                    outQtys += st.Qty;

                    //库存总表
                    var stockz = Db.Queryable<DataStock>().First(d => d.IsDel == "0" && d.SkuNo == detail.SkuNo && d.LotNo == detail.LotNo);
                    stockz.LockQty += st.Qty;
                    Db.Updateable(stockz).ExecuteCommand();
                }
                Db.Insertable(allotList).ExecuteCommand();
                //修改单据明细
                detail.AllotQty += outQtys;
                detail.UpdateUser = userId;
                detail.UpdateTime = DateTime.Now;
                if (detail.Status == "0")
                {
                    detail.Status = "1";
                }

                Db.Updateable(detail).ExecuteCommand();
                //var detailList = Db.Queryable<BllExportNoticeDetail>()
                //    .Where(m => m.IsDel == "0" && m.SONo == notice.SONo).ToList();
                //修改出库单状态 
                if (notice.Status == "0" || notice.Status == "1")
                {
                    var bl = 0;
                    var bl2 = 0;

                    if (detail.AllotQty < detail.Qty)
                    {
                        bl = 1;
                    }
                    else
                    {
                        bl2 = 1;
                    }


                    switch (bl2)
                    {
                        case 1 when bl == 1:
                            notice.Status = "1";//证明部分分配数量全部大于等于出库数量  修改为已分配
                            break;
                        case 0 when bl == 1:
                            notice.Status = "1";//证明部分分配数量全部大于等于出库数量  修改为已分配
                            break;
                        case 1 when bl == 0:
                            notice.Status = "2";//证明分配数量全部大于等于出库数量  修改为已分配
                            break;
                        case 0 when bl == 0:
                            notice.Status = "1";
                            //证明所有分配数量全部小于等于出库数量 部分分配
                            break;
                    }
                    //修改出库总单状态
                    Db.Updateable(notice).ExecuteCommand();

                }
                //添加操作日志记录
                var k = new OperationSOServer().AddLogOperationSo("出库作业", "出库单据", notice.SONo, "分配", $"手动分配了单据号为{notice.SONo}、物料：{detail.SkuNo}、批次：{detail.LotNo}的单据信息", userId);

                Db.CommitTran();

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

        #endregion

        /// <summary>
        /// 获取移库目标库位
        /// </summary>
        /// <param name="oldAddress">需要移动的库位地址</param>
        /// <param name="roadWay">巷道</param>
        /// <param name="area">区域</param>
        /// <returns>目标库位地址 为"" 直接下发两次出库指令</returns>
        public string MoveAddress(string oldAddress, string roadWay, string area)//01020201  排-列-层-深度
        {
            string nowAddress = "";
            // 获取移库目标储位
            var row = int.Parse(oldAddress.Substring(0, 2));
            var lie = int.Parse(oldAddress.Substring(2, 2));
            var ceng = int.Parse(oldAddress.Substring(4, 2));

            var sqlString = $@"select LocatNo,[Row],[Column],Layer, (ABS(Row-{row}) + ABS([Column]-{lie}) + ABS(Layer-{ceng}))  as distNum 
                                from SysStorageLocat 
                                where Flag = '0' and Status = '0' and Depth = '02' and RoadwayNo = '{roadWay}' and AreaNo = '{area}' 
                                order by distNum;";

            var addressModels = Db.Ado.SqlQuery<AddressCls>(sqlString).ToList();
            if (addressModels.Count > 0)   // 判断同巷道内排空库位
            {
                var listLocaete = new List<string>();
                foreach (var item in addressModels)
                {
                    // 目标内库位对应的外库位
                    string addressee = item.LocatNo.Substring(0, 6) + "01";

                    // 判断目标库位的外库位是否存在货物   (正常情况下正在移入情况不存在，因为移库先移入里面，后移入外面)
                    //SlotStatus 0: 空储位 1：有货  2：正在入库  3：正在出库   4：正在移入  5：正在移出
                    sqlString = $"select count(*) from SysStorageLocat where LocatNo = '{addressee}' and Status = '0' and Flag in ('0','1') ; ";
                    var rowNum = Db.Ado.SqlQuery<int>(sqlString).First();
                    if (rowNum == 0)
                    {
                        continue;
                    }
                    else
                    {
                        nowAddress = item.LocatNo;
                        break;
                    }
                }
            }
            if (nowAddress == "")
            {
                // 判断同巷道外排空库位
                sqlString = $@"select LocatNo,[Row],[Column],Layer, (ABS(Row-{row}) + ABS([Column]-{lie}) + ABS(Layer-{ceng}))  as distNum 
                                from SysStorageLocat 
                                where Flag = '0' and Status = '0' and Depth = '01' and RoadwayNo = '{roadWay}' and AreaNo = '{area}' 
                                order by distNum;";
                var adderModeling = Db.Ado.SqlQuery<AddressCls>(sqlString).ToList();
                if (adderModeling.Count > 0)
                {
                    nowAddress = adderModeling[0].LocatNo;
                }
                else
                {
                    // 库内不存在空储位  
                    nowAddress = "";
                }
            }


            return nowAddress;
        }

    }
}