JC26WMS.git - Gitblit

			@@ -3,15 +3,21 @@
			using System.ComponentModel.Design;
			using System.Linq;
			using System.Linq.Expressions;
			using System.Net;
			using System.Text;
			using System.Threading.Tasks;
			using Microsoft.AspNetCore.Identity;
			using Model.InterFaceModel;
			using Model.ModelDto.BllCheckDto;
			using Model.ModelDto.DataDto;
			using Model.ModelDto.SysDto;
			using Model.ModelVm;
			using Model.ModelVm.BllCheckVm;
			using Model.ModelVm.LogVm;
			using Newtonsoft.Json;
			using SqlSugar;
			using SqlSugar.Extensions;
			using Utility;
			using Utility.Tools;
			using WMS.BLL.LogServer;
			using WMS.DAL;
			@@ -23,238 +29,276 @@
			using WMS.Entity.LogEntity;
			using WMS.Entity.SysEntity;
			using WMS.IBLL.IBllCheckServer;
			using WMS.IBLL.ILogServer;

			namespace WMS.BLL.BllCheckServer
			{
			public class StockCheckServer : DbHelper<BllStockCheck>, IStockCheckServer
			{
			private static readonly SqlSugarScope Db = DataContext.Db;
			public StockCheckServer() : base(Db)
			private readonly UserManager _userManager;
			private readonly IOperationCRServer _operation;
			public StockCheckServer(UserManager userManager, IOperationCRServer operation) : base(Db)
			{
			_userManager = userManager;
			_operation = operation;
			}

			//获取盘点单据
			public List<StockCheckDto> GetStockCheckList(string crNo, string status, string palletNo, string skuNo, string skuName,
			string lotNo, string startTime, string endTime, int page, int limit, out int count)
			public async Task<List<StockCheckDto>> GetStockCheckList(string crNo, string status, string palletNo, string skuNo, string skuName,
			string lotNo, string startTime, string endTime, int page, int limit, RefAsync<int> count)
			{
			try
			var strList = new List<string>();

			if (!string.IsNullOrWhiteSpace(palletNo) \|\| !string.IsNullOrWhiteSpace(skuNo) \|\| !string.IsNullOrWhiteSpace(skuName) \|\| !string.IsNullOrWhiteSpace(lotNo))
			{
			var strList = new List<string>();

			if (!string.IsNullOrWhiteSpace(palletNo) \|\| !string.IsNullOrWhiteSpace(skuNo) \|\| !string.IsNullOrWhiteSpace(skuName) \|\| !string.IsNullOrWhiteSpace(lotNo))
			{
			Expression<Func<BllStockCheckDetail, bool>> demo = Expressionable.Create<BllStockCheckDetail>()
			.AndIF(!string.IsNullOrWhiteSpace(palletNo), m => m.PalletNo.Contains(palletNo.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(skuNo), m => m.SkuNo.Contains(skuNo.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(skuName), m => m.SkuName.Contains(skuName.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(lotNo), m => m.LotNo.Contains(lotNo.Trim()))
			.And(m => m.IsDel == "0")
			.ToExpression();//注意这一句不能少

			var detailList = Db.Queryable<BllStockCheckDetail>().Where(demo).Select(m => m.CRNo).Distinct().ToList();
			strList = detailList;
			}

			Expression<Func<BllStockCheck, bool>> item = Expressionable.Create<BllStockCheck>()
			.AndIF(!string.IsNullOrWhiteSpace(crNo), m => m.CRNo.Contains(crNo.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(status), m => m.Status == int.Parse(status))
			.AndIF(!string.IsNullOrWhiteSpace(startTime), m => m.CheckDate >= Convert.ToDateTime(startTime))
			.AndIF(!string.IsNullOrWhiteSpace(endTime), m => m.CheckDate <= Convert.ToDateTime(endTime).AddDays(1))
			.AndIF(!string.IsNullOrWhiteSpace(palletNo), m => strList.Contains(m.CRNo))
			.AndIF(!string.IsNullOrWhiteSpace(skuNo), m => strList.Contains(m.CRNo))
			.AndIF(!string.IsNullOrWhiteSpace(skuName), m => strList.Contains(m.CRNo))
			.AndIF(!string.IsNullOrWhiteSpace(lotNo), m => strList.Contains(m.CRNo))
			Expression<Func<BllStockCheckDetail, bool>> demo = Expressionable.Create<BllStockCheckDetail>()
			.AndIF(!string.IsNullOrWhiteSpace(palletNo), m => m.PalletNo.Contains(palletNo.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(skuNo), m => m.SkuNo.Contains(skuNo.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(skuName), m => m.SkuName.Contains(skuName.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(lotNo), m => m.LotNo.Contains(lotNo.Trim()))
			.And(m => m.IsDel == "0")
			.ToExpression();//注意这一句不能少
			var total = 0;
			var list = Db.Queryable<BllStockCheck>().Where(item)
			.LeftJoin<SysUserInfor>((a, b) => a.AuditUser == b.Id)
			.LeftJoin<SysUserInfor>((a, b, c) => a.CreateUser == c.Id)
			.LeftJoin<SysUserInfor>((a, b, c, d) => a.CreateUser == d.Id)
			.Select((a, b, c, d) => new StockCheckDto()
			{
			Id = a.Id,
			CrNo = a.CRNo,
			CheckDate = a.CheckDate,
			CompleteDate = a.CompleteDate,
			Status = a.Status,
			Origin = a.Origin,
			AuditStatusNo = a.AuditStatusNo,
			IsDoubleCheck = a.IsDoubleCheck,
			AuditUserName = b.RealName,
			AuditTime = a.AuditTime,
			Demo = a.Demo,

			CreateUserName = c.RealName,
			UpdateUserName = d.RealName,
			CreateTime = a.CreateTime,
			UpdateTime = a.UpdateTime,

			}).OrderByDescending(a => a.CreateTime).ToOffsetPage(page, limit, ref total);
			count = total;

			return list;

			var detailList = await Db.Queryable<BllStockCheckDetail>().Where(demo).Select(m => m.CRNo).Distinct().ToListAsync();
			strList = detailList;
			}
			catch (Exception e)
			{
			throw new Exception(e.Message);
			}

			Expression<Func<BllStockCheck, bool>> item = Expressionable.Create<BllStockCheck>()
			.AndIF(!string.IsNullOrWhiteSpace(crNo), m => m.CRNo.Contains(crNo.Trim()))
			.AndIF(!string.IsNullOrWhiteSpace(status), m => m.Status == int.Parse(status))
			.AndIF(!string.IsNullOrWhiteSpace(startTime), m => m.CheckDate >= Convert.ToDateTime(startTime))
			.AndIF(!string.IsNullOrWhiteSpace(endTime), m => m.CheckDate <= Convert.ToDateTime(endTime).AddDays(1))
			.AndIF(!string.IsNullOrWhiteSpace(palletNo), m => strList.Contains(m.CRNo))
			.AndIF(!string.IsNullOrWhiteSpace(skuNo), m => strList.Contains(m.CRNo))
			.AndIF(!string.IsNullOrWhiteSpace(skuName), m => strList.Contains(m.CRNo))
			.AndIF(!string.IsNullOrWhiteSpace(lotNo), m => strList.Contains(m.CRNo))
			.And(m => m.IsDel == "0")
			.ToExpression();//注意这一句不能少
			var list = await Db.Queryable<BllStockCheck>().Where(item)
			.LeftJoin<SysUserInfor>((a, b) => a.AuditUser == b.Id)
			.LeftJoin<SysUserInfor>((a, b, c) => a.CreateUser == c.Id)
			.LeftJoin<SysUserInfor>((a, b, c, d) => a.CreateUser == d.Id)
			.Select((a, b, c, d) => new StockCheckDto()
			{
			Id = a.Id,
			CrNo = a.CRNo,
			CheckDate = a.CheckDate,
			CompleteDate = a.CompleteDate,
			Status = a.Status,
			Origin = a.Origin,
			AuditStatusNo = a.AuditStatusNo,
			IsDoubleCheck = a.IsDoubleCheck,
			AuditUserName = b.RealName,
			AuditTime = a.AuditTime,
			Demo = a.Demo,
			CreateUserName = c.RealName,
			UpdateUserName = d.RealName,
			CreateTime = a.CreateTime,
			UpdateTime = a.UpdateTime,
			}).OrderByDescending(a => a.CreateTime).ToPageListAsync(page, limit, count);

			return list;
			}

			//获取盘点单据明细
			public List<StockCheckDetailDto> GetStockCheckDetailList(string crNo, int page, int limit, out int count)
			public async Task<List<StockCheckDetailDto>> GetStockCheckDetailList(string crNo, int page, int limit, RefAsync<int> count)
			{
			try
			{
			var total = 0;
			var list = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == crNo)
			.LeftJoin<SysUserInfor>((a, b) => a.CreateUser == b.Id)
			.LeftJoin<SysUserInfor>((a, b, c) => a.UpdateUser == c.Id)
			.Select((a, b, c) => new StockCheckDetailDto()
			{
			Id = a.Id,
			CrNo = a.CRNo,
			PalletNo = a.PalletNo,
			Qty = a.Qty,
			RealQty = a.RealQty,
			CheckResult = a.CheckResult,
			Status = a.Status,
			SkuNo = a.SkuNo,
			SkuName = a.SkuName,
			Standard = a.Standard,
			LotNo = a.LotNo,
			LotText = a.LotText,
			SupplierLot = a.SupplierLot,
			return await Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == crNo)
			.LeftJoin<SysUserInfor>((a, b) => a.CreateUser == b.Id)
			.LeftJoin<SysUserInfor>((a, b, c) => a.UpdateUser == c.Id)
			.Select((a, b, c) => new StockCheckDetailDto()
			{
			Id = a.Id,
			CrNo = a.CRNo,
			PalletNo = a.PalletNo,
			Qty = a.Qty,
			RealQty = a.RealQty,
			CheckResult = a.CheckResult,
			Status = a.Status,
			SkuNo = a.SkuNo,
			SkuName = a.SkuName,
			Standard = a.Standard,
			LotNo = a.LotNo,
			LotText = a.LotText,
			SupplierLot = a.SupplierLot,

			CreateUserName = b.RealName,
			UpdateUserName = c.RealName,
			CreateTime = a.CreateTime,
			UpdateTime = a.UpdateTime,
			CreateUserName = b.RealName,
			UpdateUserName = c.RealName,
			CreateTime = a.CreateTime,
			UpdateTime = a.UpdateTime,

			}).ToOffsetPage(page, limit, ref total);
			count = total;

			return list;
			}
			catch (Exception e)
			{
			throw new Exception(e.Message);
			}
			}).ToPageListAsync(page, limit, count);
			}

			//获取库存明细信息（盘点选择明细数据源）
			public List<StockDetailDto> GetCheckStockDetailList(string houseNo, string roadwayNo, string locateNo, string msg, int page, int limit, out int count)
			public async Task<List<StockDetailDto>> GetCheckStockDetailList(string houseNo, string roadwayNo, string locateNo, string msg, int page, int limit, RefAsync<int> count)
			{
			try
			{
			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(msg),
			m => m.SkuNo.Contains(msg.Trim())
			\|\| m.SkuName.Contains(msg.Trim())
			\|\| m.LotNo.Contains(msg.Trim()))
			.And(m => m.IsDel == "0" && m.SkuNo != "100099" && m.Status == "0")
			.ToExpression();//注意这一句不能少

			var total = 0;
			var list = Db.Queryable<DataStockDetail>().Where(item).GroupBy(m => new { m.SkuNo, m.SkuName, m.Standard, m.LotNo, m.LotText, m.SupplierLot, m.LocatNo, m.PalletNo })
			.Select(a => new StockDetailDto()
			{
			SkuNo = a.SkuNo,
			SkuName = a.SkuName,
			Standard = a.Standard,
			LotNo = a.LotNo,
			LotText = a.LotText,
			SupplierLot = a.SupplierLot,
			Qty = SqlFunc.AggregateSum(a.Qty),
			LocatNo = a.LocatNo,
			PalletNo = a.PalletNo
			}).ToOffsetPage(page, limit, ref total);
			count = total;

			return list;
			}
			catch (Exception e)
			{
			throw new Exception(e.Message);
			}
			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(msg),
			m => m.SkuNo.Contains(msg.Trim())
			\|\| m.SkuName.Contains(msg.Trim())
			\|\| m.LotNo.Contains(msg.Trim()))
			.And(m => m.IsDel == "0" && m.SkuNo != "100099" && m.Status == "0")
			.ToExpression();//注意这一句不能少
			return await Db.Queryable<DataStockDetail>().Where(item).GroupBy(m => new { m.SkuNo, m.SkuName, m.Standard, m.LotNo, m.LotText, m.SupplierLot, m.LocatNo, m.PalletNo })
			.Select(a => new StockDetailDto()
			{
			SkuNo = a.SkuNo,
			SkuName = a.SkuName,
			Standard = a.Standard,
			LotNo = a.LotNo,
			LotText = a.LotText,
			SupplierLot = a.SupplierLot,
			Qty = SqlFunc.AggregateSum(a.Qty),
			LocatNo = a.LocatNo,
			PalletNo = a.PalletNo
			}).ToPageListAsync(page, limit, count);
			}

			public EditStockCheckDto GetStockCheckDetailById(string crNo)
			public async Task<EditStockCheckDto> GetStockCheckDetailById(string crNo)
			{
			try
			var notify = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.CRNo == crNo && m.IsDel == "0");
			if (notify == null)
			{
			var notify = Db.Queryable<BllStockCheck>().First(m => m.CRNo == crNo && m.IsDel == "0");
			if (notify == null)
			{
			throw new Exception($"未查询到{crNo}的盘点单据信息");
			}
			var detail = Db.Queryable<BllStockCheckDetail>().Where(m => m.CRNo == crNo && m.IsDel == "0").Select(m => new EditStockCheckDetailDto()
			{
			SkuNo = m.SkuNo,
			SkuName = m.SkuName,
			Standard = m.Standard,
			LotNo = m.LotNo,
			LotText = m.LotText,
			SupplierLot = m.SupplierLot,
			Qty = m.Qty,

			PalletNo = m.PalletNo
			}).ToList();
			var data = new EditStockCheckDto()
			{
			CrNo = crNo,
			Detail = detail
			};

			return data;
			throw new Exception($"未查询到{crNo}的盘点单据信息");
			}
			catch (Exception e)
			var detail = await Db.Queryable<BllStockCheckDetail>().Where(m => m.CRNo == crNo && m.IsDel == "0").Select(m => new EditStockCheckDetailDto()
			{
			throw new Exception(e.Message);
			}
			SkuNo = m.SkuNo,
			SkuName = m.SkuName,
			Standard = m.Standard,
			LotNo = m.LotNo,
			LotText = m.LotText,
			SupplierLot = m.SupplierLot,
			Qty = m.Qty,

			PalletNo = m.PalletNo
			}).ToListAsync();
			var data = new EditStockCheckDto()
			{
			CrNo = crNo,
			Detail = detail
			};

			return data;
			}


			//添加盘点单、编辑盘点单
			public void AddEditStockCheck(AddEditStockCheckVm model, int userId)
			public async Task AddEditStockCheck(AddEditStockCheckVm model)
			{
			try
			if (model.Detail.Count == 0)
			{
			if (model.Detail.Count == 0)
			{
			throw new Exception("盘点明细不能为空");
			}
			Db.BeginTran();
			var time = DateTime.Now;
			throw Oops.Bah("盘点明细不能为空");
			}
			var time = DateTime.Now;

			//添加
			if (string.IsNullOrWhiteSpace(model.CrNo))
			//添加
			if (string.IsNullOrWhiteSpace(model.CrNo))
			{
			var num = await Db.Queryable<BllStockCheck>().CountAsync(m => m.IsDel == "0" && (m.Status == 0 \|\| m.Status == 1));
			if (num > 0)
			{
			var num = Db.Queryable<BllStockCheck>().Count(m => m.IsDel == "0" && (m.Status == 0 \|\| m.Status == 1));
			if (num > 0)
			{
			throw new Exception("已有等待执行的盘点单据请先完成或删除");
			}
			var crNo = new Common().GetMaxNo("CR");
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0");
			var check = new BllStockCheck()
			throw Oops.Bah("已有等待执行的盘点单据请先完成或删除");
			}
			var crNo = new Common().GetMaxNo("CR");
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0");
			var check = new BllStockCheck()
			{
			CRNo = crNo,
			Origin = "0",
			Status = 0,
			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			var list = new List<BllStockCheckDetail>();
			foreach (var item in model.Detail)
			{
			var detail = new BllStockCheckDetail()
			{
			CRNo = crNo,
			Origin = "0",
			Status = 0,
			CreateUser = userId,
			PalletNo = item.PalletNo,
			Qty = item.Qty,
			Status = 0, //0：未盘 1：已盘 2：已调整
			SkuNo = item.SkuNo,
			SkuName = item.SkuName,
			Standard = item.Standard,
			LotNo = item.LotNo,
			LotText = item.LotText,
			SupplierLot = item.SupplierLot,
			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			var list = new List<BllStockCheckDetail>();
			foreach (var item in model.Detail)
			list.Add(detail);
			var sd = await stockDetail.FirstAsync(m => m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo && m.Status == "0");
			sd.Status = "3";
			Db.Updateable(sd).ExecuteCommand();
			}
			Db.Insertable(check).ExecuteCommand();
			Db.Insertable(list).ExecuteCommand();
			//添加操作日志记录
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = crNo,
			TypeName = "添加",
			Msg = $"添加了单据号为{crNo}的盘点单信息"
			});
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", crNo, "添加", $"添加了单据号为{crNo}的盘点单信息", _userManager.UserId);
			}
			else //编辑
			{
			var check = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.IsDel == "0" && m.CRNo == model.CrNo);
			if (check == null)
			{
			throw Oops.Bah("未查询到盘点单据的信息");
			}
			check.UpdateUser = _userManager.UserId;
			check.UpdateTime = time;
			await Db.Updateable(check).ExecuteCommandAsync();

			//盘点明细信息
			var checkDetail = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == model.CrNo).ToList();

			//删除旧的
			foreach (var d in checkDetail)
			{
			var mq = model.Detail.Where(o => o.SkuNo == d.SkuNo && o.LotNo == d.LotNo && o.PalletNo == d.PalletNo).ToList();
			if (mq.Any()) //如果有这个物料及批次则跳过
			{
			continue;
			}

			var sd = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.SkuNo == d.SkuNo && m.LotNo == d.LotNo && m.PalletNo == d.PalletNo && m.Status == "3").ToList();
			foreach (var s in sd)
			{
			s.Status = "0";

			}
			d.IsDel = "1";
			d.UpdateUser = _userManager.UserId;
			d.UpdateTime = time;
			//修改库存明细的状态（解除盘点锁定）
			await Db.Updateable(sd).ExecuteCommandAsync();
			await Db.Updateable(d).ExecuteCommandAsync();
			}

			//添加与修改
			var list = new List<BllStockCheckDetail>();
			foreach (var item in model.Detail)
			{
			var de = checkDetail.FirstOrDefault(m => m.PalletNo == item.PalletNo && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo);
			//新加项
			if (de == null)
			{
			var detail = new BllStockCheckDetail()
			{
			CRNo = crNo,
			CRNo = model.CrNo,
			PalletNo = item.PalletNo,
			Qty = item.Qty,
			Status = 0, //0：未盘 1：已盘 2：已调整
			@@ -265,163 +309,90 @@
			LotText = item.LotText,
			SupplierLot = item.SupplierLot,

			CreateUser = userId,
			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			list.Add(detail);
			var sd = stockDetail.First(m => m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo && m.Status == "0");
			sd.Status = "3";
			Db.Updateable(sd).ExecuteCommand();
			}
			Db.Insertable(check).ExecuteCommand();
			Db.Insertable(list).ExecuteCommand();
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", crNo, "添加", $"添加了单据号为{crNo}的盘点单信息", userId);
			}
			else //编辑
			{
			var check = Db.Queryable<BllStockCheck>().First(m => m.IsDel == "0" && m.CRNo == model.CrNo);
			if (check == null)
			{
			throw new Exception("未查询到盘点单据的信息");
			}
			check.UpdateUser = userId;
			check.UpdateTime = time;
			Db.Updateable(check).ExecuteCommand();

			//盘点明细信息
			var checkDetail = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == model.CrNo).ToList();

			//删除旧的
			foreach (var d in checkDetail)
			{
			var mq = model.Detail.Where(o => o.SkuNo == d.SkuNo && o.LotNo == d.LotNo && o.PalletNo == d.PalletNo).ToList();
			if (mq.Any()) //如果有这个物料及批次则跳过
			{
			continue;
			}

			var sd = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.SkuNo == d.SkuNo && m.LotNo == d.LotNo && m.PalletNo == d.PalletNo && m.Status == "3").ToList();
			var sd = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo && m.Status == "0").ToList();
			foreach (var s in sd)
			{
			s.Status = "0";

			s.Status = "3";
			}
			d.IsDel = "1";
			d.UpdateUser = userId;
			d.UpdateTime = time;
			//修改库存明细的状态（解除盘点锁定）
			Db.Updateable(sd).ExecuteCommand();
			Db.Updateable(d).ExecuteCommand();
			await Db.Updateable(sd).ExecuteCommandAsync();
			}

			//添加与修改
			var list = new List<BllStockCheckDetail>();
			foreach (var item in model.Detail)
			else if (de.Qty != item.Qty)
			{
			var de = checkDetail.FirstOrDefault(m => m.PalletNo == item.PalletNo && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo);
			//新加项
			if (de == null)
			{
			var detail = new BllStockCheckDetail()
			{
			CRNo = model.CrNo,
			PalletNo = item.PalletNo,
			Qty = item.Qty,
			Status = 0, //0：未盘 1：已盘 2：已调整
			SkuNo = item.SkuNo,
			SkuName = item.SkuName,
			Standard = item.Standard,
			LotNo = item.LotNo,
			LotText = item.LotText,
			SupplierLot = item.SupplierLot,

			CreateUser = userId,
			CreateTime = time
			};
			list.Add(detail);
			var sd = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo && m.Status == "0").ToList();
			foreach (var s in sd)
			{
			s.Status = "3";
			}
			Db.Updateable(sd).ExecuteCommand();
			}
			else if (de.Qty != item.Qty)
			{
			de.Qty = item.Qty;
			de.UpdateUser = userId;
			de.UpdateTime = time;
			Db.Updateable(de).ExecuteCommand();
			}

			de.Qty = item.Qty;
			de.UpdateUser = _userManager.UserId;
			de.UpdateTime = time;
			await Db.Updateable(de).ExecuteCommandAsync();
			}

			if (list.Count > 0)
			{
			Db.Insertable(list).ExecuteCommand();
			}

			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", model.CrNo, "编辑", $"编辑了单据号为{model.CrNo}的盘点单信息", userId);
			}
			Db.CommitTran();

			}
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			if (list.Count > 0)
			{
			await Db.Insertable(list).ExecuteCommandAsync();
			}

			//添加操作日志记录
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = model.CrNo,
			TypeName = "编辑",
			Msg = $"编辑了单据号为{model.CrNo}的盘点单信息"
			});
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", model.CrNo, "编辑", $"编辑了单据号为{model.CrNo}的盘点单信息", _userManager.UserId);
			}
			}

			//删除盘点单
			public void DelStockCheck(int id, int userId)
			public async Task DelStockCheck(int id)
			{
			try
			var notice = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.IsDel == "0" && m.Id == id);
			if (notice == null \|\| notice.Status != 0)
			{
			var notice = Db.Queryable<BllStockCheck>().First(m => m.IsDel == "0" && m.Id == id);
			if (notice == null \|\| notice.Status != 0)
			{
			throw new Exception("未查询到状态为等待执行的盘点单信息");
			}

			var detail = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToList();
			if (detail.Count == 0)
			{
			throw new Exception("未查询到盘点单据明细信息");
			}
			Db.BeginTran();
			var time = DateTime.Now;
			foreach (var d in detail)
			{
			d.IsDel = "1";
			d.UpdateTime = time;
			d.UpdateUser = userId;
			var item = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == d.PalletNo && m.SkuNo == d.SkuNo && m.LotNo == d.LotNo && m.Status == "3").ToList();
			foreach (var i in item)
			{
			i.Status = "0";
			}
			Db.Updateable(item).ExecuteCommand();
			}

			notice.IsDel = "1";
			notice.UpdateTime = time;
			notice.UpdateUser = userId;

			Db.Updateable(notice).ExecuteCommand();
			Db.Updateable(detail).ExecuteCommand();
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "删除", $"删除了单据号为{notice.CRNo}的盘点单信息", userId);
			Db.CommitTran();

			throw Oops.Bah("未查询到状态为等待执行的盘点单信息");
			}
			catch (Exception e)

			var detail = await Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToListAsync();
			if (detail.Count == 0)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			throw Oops.Bah("未查询到盘点单据明细信息");
			}
			var time = DateTime.Now;
			foreach (var d in detail)
			{
			d.IsDel = "1";
			d.UpdateTime = time;
			d.UpdateUser = _userManager.UserId;
			var item = await Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == d.PalletNo && m.SkuNo == d.SkuNo && m.LotNo == d.LotNo && m.Status == "3").ToListAsync();
			foreach (var i in item)
			{
			i.Status = "0";
			}
			await Db.Updateable(item).ExecuteCommandAsync();
			}

			notice.IsDel = "1";
			notice.UpdateTime = time;
			notice.UpdateUser = _userManager.UserId;

			await Db.Updateable(notice).ExecuteCommandAsync();
			await Db.Updateable(detail).ExecuteCommandAsync();
			//添加操作日志记录
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = notice.CRNo,
			TypeName = "删除",
			Msg = $"删除了单据号为{notice.CRNo}的盘点单信息"
			});
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "删除", $"删除了单据号为{notice.CRNo}的盘点单信息", userId);

			}

			/// <summary>
			@@ -430,24 +401,32 @@
			/// <param name="id"></param>
			/// <param name="demo"></param>
			/// <param name="userId"></param>
			public void EditNoticeDemo(int id, string demo, int userId)
			public async Task EditNoticeDemo(int id, string demo)
			{
			try
			{
			var notice = Db.Queryable<BllStockCheck>().First(m => m.IsDel == "0" && m.Id == id);
			var notice = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.IsDel == "0" && m.Id == id);
			if (notice == null)
			{
			throw new Exception("未查询到盘点单据信息");
			}
			notice.Demo = demo + "".Trim();
			notice.UpdateUser = userId;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = DateTime.Now;

			int i = Db.Updateable(notice).ExecuteCommand();
			if (i > 0)
			{
			//添加操作日志
			new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "编辑", $"编辑了单据号为{notice.CRNo}的备注信息", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = notice.CRNo,
			TypeName = "编辑",
			Msg = $"编辑了单据号为{notice.CRNo}的备注信息"
			});
			//new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "编辑", $"编辑了单据号为{notice.CRNo}的备注信息", userId);
			}
			}
			catch (Exception ex)
			@@ -457,39 +436,39 @@
			}

			//调整库存
			public bool StockAdjust(int id, int userId)
			public async Task StockAdjust(int id)
			{
			try
			{
			//盘点信息
			var notice = Db.Queryable<BllStockCheck>().First(m => m.IsDel == "0" && m.Id == id);
			var notice = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.IsDel == "0" && m.Id == id);
			if (notice == null \|\| notice.Status != 2)
			{
			throw new Exception("未查询到状态为盘点完成的盘点单信息");
			throw Oops.Bah("未查询到状态为盘点完成的盘点单信息");
			}
			if (notice == null \|\| notice.Status != 2)
			{
			throw new Exception("未查询到状态为盘点完成的盘点单信息");
			throw Oops.Bah("未查询到状态为盘点完成的盘点单信息");
			}
			//盘点明细
			var detail = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToList();
			var detail = await Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToListAsync();
			if (detail.Count == 0)
			{
			throw new Exception("未查询到盘点单据明细信息");
			throw Oops.Bah("未查询到盘点单据明细信息");
			}
			//开启事务
			Db.BeginTran();
			var stock = Db.Queryable<DataStock>().Where(m => m.IsDel == "0").ToList();//库存表
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0").ToList();//库存明细
			var stockBox = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0").ToList();//库存箱支明细
			var materialList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();//物料信息
			var packagList = Db.Queryable<SysPackag>().Where(m => m.IsDel == "0").ToList();//包装信息
			var stock = await Db.Queryable<DataStock>().Where(m => m.IsDel == "0").ToListAsync();//库存表
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0").ToListAsync();//库存明细
			var stockBox = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0").ToListAsync();//库存箱支明细
			var materialList = await Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToListAsync();//物料信息
			var packagList = await Db.Queryable<SysPackag>().Where(m => m.IsDel == "0").ToListAsync();//包装信息
			var time = DateTime.Now;
			//盘点记录
			var checkLog = Db.Queryable<BllStockCheckLog>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToList();
			var checkLog = await Db.Queryable<BllStockCheckLog>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToListAsync();
			if (checkLog.Count(m => m.CheckResult == null) > 0)
			{
			throw new Exception($"{notice.CRNo}单据中含有未盘点的信息，请核实!");
			throw Oops.Bah($"{notice.CRNo}单据中含有未盘点的信息，请核实!");
			}
			List<BoxQtyInfo> boxQtyList = new List<BoxQtyInfo>();

			@@ -541,10 +520,10 @@
			foreach (var d in detail)
			{
			var demo = checkLog.Where(m => m.PalletNo == d.PalletNo).ToList();//盘点记录
			//循环盘点记录
			//循环盘点记录
			foreach (var l in demo)
			{
			var sku = Db.Queryable<SysMaterials>().First(a => a.IsDel == "0" && a.SkuNo == l.SkuNo);
			var sku = await Db.Queryable<SysMaterials>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == l.SkuNo);
			if (l.CheckResult == 0)//正常
			{
			if (sku.Type != "4")
			@@ -552,25 +531,25 @@
			var de3 = stockBox.First(m => m.BoxNo == l.BoxNo && m.BoxNo3 == l.BoxNo3);
			if (de3 == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存箱码的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存箱码的信息");
			}
			var de2 = stockDetail.First(m => m.Id == de3.StockDetailId);
			if (de2 == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存明细的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存明细的信息");
			}
			de2.Status = "0";//将库存明细状态改为待分配
			Db.Updateable(de2).ExecuteCommand();
			await Db.Updateable(de2).ExecuteCommandAsync();
			}
			else
			{
			var de2 = stockDetail.First(m => m.PalletNo == l.PalletNo && m.SkuNo == l.SkuNo);
			if (de2 == null)
			{
			throw new Exception($"未查询到{l.PalletNo}的库存明细的信息");
			throw Oops.Bah($"未查询到{l.PalletNo}的库存明细的信息");
			}
			de2.Status = "0";//将库存明细状态改为待分配
			Db.Updateable(de2).ExecuteCommand();
			await Db.Updateable(de2).ExecuteCommandAsync();
			}

			}
			@@ -581,13 +560,13 @@
			var de3 = stockBox.First(m => m.BoxNo == l.BoxNo && m.BoxNo3 == l.BoxNo3);
			if (de3 == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存箱码的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存箱码的信息");
			}

			var de2 = stockDetail.First(m => m.Id == de3.StockDetailId);
			if (de2 == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存明细的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存明细的信息");
			}
			de2.Status = "0";
			de2.Qty -= de3.Qty;
			@@ -598,30 +577,29 @@
			}
			de.Qty -= de3.Qty;

			Db.Updateable(de).ExecuteCommand();
			Db.Updateable(de2).ExecuteCommand();
			Db.Deleteable(de3).ExecuteCommand();
			await Db.Updateable(de).ExecuteCommandAsync();
			await Db.Updateable(de2).ExecuteCommandAsync();
			await Db.Deleteable(de3).ExecuteCommandAsync();
			}
			else
			{
			var de2 = stockDetail.First(m => m.PalletNo == l.PalletNo && m.SkuNo == l.SkuNo);
			if (de2 == null)
			{
			throw new Exception($"未查询到{l.PalletNo}的库存明细的信息");
			throw Oops.Bah($"未查询到{l.PalletNo}的库存明细的信息");
			}
			de2.Status = "0";
			de2.Qty = l.RealQty;
			var de = stock.First(m => m.SkuNo == l.SkuNo && m.LotNo == l.LotNo);
			if (de == null)
			{
			throw new Exception($"未查询到物料{l.SkuNo}批次{l.LotNo}的总库存的信息");
			throw Oops.Bah($"未查询到物料{l.SkuNo}批次{l.LotNo}的总库存的信息");
			}
			de.Qty -= Convert.ToDecimal(l.Qty - l.RealQty);

			Db.Updateable(de).ExecuteCommand();
			Db.Updateable(de2).ExecuteCommand();
			await Db.Updateable(de).ExecuteCommandAsync();
			await Db.Updateable(de2).ExecuteCommandAsync();
			}

			}
			else if (l.CheckResult == 2)//盘盈
			{
			@@ -656,7 +634,7 @@
			ProductionTime = stockBoxInfo.ProductionTime,
			BitBoxMark = boxInfo.bitBoxMark,
			};
			Db.Insertable<DataBoxInfo>(databox).ExecuteCommand();
			await Db.Insertable<DataBoxInfo>(databox).ExecuteCommandAsync();
			//库存明细增加数量
			stockDetailInfo.Qty += (int)l.RealQty;
			}
			@@ -667,12 +645,12 @@
			}
			stockDetailInfo.Status = "0";

			Db.Updateable(stockDetailInfo).ExecuteCommand();
			await Db.Updateable(stockDetailInfo).ExecuteCommandAsync();
			//库存增加数量
			var de = stock.First(m => m.SkuNo == l.SkuNo && m.LotNo == l.LotNo);
			if (de == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存的信息");
			}
			if (sku.Type != "4")
			{
			@@ -683,13 +661,13 @@
			de.Qty += (int)(l.RealQty - l.Qty);
			}

			Db.Updateable(de).ExecuteCommand();
			await Db.Updateable(de).ExecuteCommandAsync();
			}
			}
			//修改盘点明细
			d.Status = 4;//状态
			d.UpdateTime = time;
			d.UpdateUser = userId;
			d.UpdateUser = _userManager.UserId;
			//盘点结果
			if (d.Qty == d.RealQty)
			{
			@@ -707,18 +685,18 @@
			{
			d.CheckResult = 1;
			}
			Db.Updateable(d).ExecuteCommand();
			await Db.Updateable(d).ExecuteCommandAsync();

			#region 添加判断盘点完托盘是否是零托
			var material = materialList.FirstOrDefault(m => m.SkuNo == d.SkuNo);
			if (material == null)
			{
			throw new Exception($"未查询到{d.SkuNo}的物料信息；");
			throw Oops.Bah($"未查询到{d.SkuNo}的物料信息；");
			}
			var pack = packagList.FirstOrDefault(m => m.PackagNo == material.PackagNo);
			if (pack == null)
			{
			throw new Exception($"未查询到{d.SkuNo}的包装信息；");
			throw Oops.Bah($"未查询到{d.SkuNo}的包装信息；");
			}
			var pNum = 0;//托盘物品数量
			var bNum = 0;//箱物品数量
			@@ -744,7 +722,7 @@
			}
			if (pNum == 0)
			{
			throw new Exception("未查询到物料包装托箱关系信息");
			throw Oops.Bah("未查询到物料包装托箱关系信息");
			}
			var stockDetailInfo2 = stockDetail.First(m => m.PalletNo == d.PalletNo && m.SkuNo == d.SkuNo && m.LotNo == d.LotNo);//库存明细
			if (stockDetailInfo2.Qty >= pNum)
			@@ -756,20 +734,27 @@
			stockDetailInfo2.BitPalletMark = "1";
			}

			Db.Updateable(stockDetailInfo2).ExecuteCommand();
			await Db.Updateable(stockDetailInfo2).ExecuteCommandAsync();
			#endregion
			}
			//修该盘点信息
			notice.Status = 3;//状态
			notice.UpdateTime = time;
			notice.UpdateUser = userId;
			Db.Updateable(notice).ExecuteCommand();
			notice.UpdateUser = _userManager.UserId;
			await Db.Updateable(notice).ExecuteCommandAsync();
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "调整单据", $"调整了单据号为{notice.CRNo}的盘点单信息", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "调整单据", $"调整了单据号为{notice.CRNo}的盘点单信息", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = notice.CRNo,
			TypeName = "调整单据",
			Msg = $"调整了单据号为{notice.CRNo}的盘点单信息"
			});

			//提交事务
			Db.CommitTran();
			return true;
			}
			catch (Exception e)
			{
			@@ -780,7 +765,7 @@
			}

			//调整库存-针对异常生成的
			public bool StockAdjustAuto(int id, int userId)
			public async Task StockAdjustAuto(int id)
			{
			try
			{
			@@ -788,55 +773,54 @@
			var notice = Db.Queryable<BllStockCheck>().First(m => m.IsDel == "0" && m.Id == id);
			if (notice == null \|\| notice.Status != 2)
			{
			throw new Exception("未查询到状态为盘点完成的盘点单信息");
			throw Oops.Bah("未查询到状态为盘点完成的盘点单信息");
			}
			//盘点明细
			var detail = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo).ToList();
			if (detail.Count == 0)
			{
			throw new Exception("未查询到盘点单据明细信息");
			throw Oops.Bah("未查询到盘点单据明细信息");
			}
			//开启事务
			Db.BeginTran();

			var stock = Db.Queryable<DataStock>().Where(m => m.IsDel == "0");//库存
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0");//库存明细
			var stockBox = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0");//库存箱支信息
			var time = DateTime.Now;
			//盘点记录
			var checkLog = Db.Queryable<BllStockCheckLog>().Where(m => m.IsDel == "0" && m.CRNo == notice.CRNo);
			if (checkLog.Count(m => m.CheckResult == null) > 0)
			if (await checkLog.CountAsync(m => m.CheckResult == null) > 0)
			{
			throw new Exception($"{notice.CRNo}单据中含有未盘点的信息，请核实!");
			}
			foreach (var d in detail)
			{
			//托盘绑定表
			var palletBind = Db.Queryable<BllPalletBind>().First(m => m.PalletNo == d.PalletNo);
			var palletBind = await Db.Queryable<BllPalletBind>().FirstAsync(m => m.PalletNo == d.PalletNo);
			//储位表
			var storageLocat = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == palletBind.LocatNo);
			var storageLocat = await Db.Queryable<SysStorageLocat>().FirstAsync(m => m.LocatNo == palletBind.LocatNo);
			if (storageLocat != null && storageLocat.Flag == "1")
			{
			//将储位标志Flag修改为：0：正常
			storageLocat.Flag = "0";
			storageLocat.UpdateUser = userId;
			storageLocat.UpdateUser = _userManager.UserId;
			storageLocat.UpdateTime = time;

			Db.Updateable(storageLocat).ExecuteCommand();
			await Db.Updateable(storageLocat).ExecuteCommandAsync();
			}
			//条码管理(托盘)
			var pallets = Db.Queryable<SysPallets>().First(m => m.PalletNo == d.PalletNo);
			var pallets = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == d.PalletNo);
			if (pallets != null && pallets.Status == "1")
			{
			//将托盘号状态变更为 0 未使用
			pallets.Status = "0";
			pallets.UpdateUser = userId;
			pallets.UpdateUser = _userManager.UserId;
			pallets.UpdateTime = time;

			Db.Updateable(pallets).ExecuteCommand();
			await Db.Updateable(pallets).ExecuteCommandAsync();
			}
			//盘点记录
			var demo = checkLog.Where(m => m.PalletNo == d.PalletNo).ToList();
			var demo = await checkLog.Where(m => m.PalletNo == d.PalletNo).ToListAsync();
			foreach (var l in demo)
			{
			if (l.CheckResult == 0)//正常
			@@ -846,48 +830,55 @@
			else if (l.CheckResult == 1)//盘亏
			{
			//物理删除库存箱支信息
			var de3 = stockBox.First(m => m.BoxNo == l.BoxNo && m.BoxNo3 == l.BoxNo3);
			var de3 = await stockBox.FirstAsync(m => m.BoxNo == l.BoxNo && m.BoxNo3 == l.BoxNo3);
			if (de3 == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存箱码的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存箱码的信息");
			}
			Db.Deleteable(de3).ExecuteCommand();
			await Db.Deleteable(de3).ExecuteCommandAsync();
			//物理删除库存明细
			var de2 = stockDetail.First(m => m.Id == de3.StockDetailId);
			var de2 = await stockDetail.FirstAsync(m => m.Id == de3.StockDetailId);
			if (de2 == null)
			{
			throw new Exception($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存明细的信息");
			throw Oops.Bah($"未查询到{l.BoxNo}箱中{l.BoxNo3}库存明细的信息");
			}
			Db.Deleteable(de2).ExecuteCommand();
			await Db.Deleteable(de2).ExecuteCommandAsync();
			//更改库存数量和锁定数量
			var de = stock.First(m => m.SkuNo == l.SkuNo && m.LotNo == l.LotNo);
			var de = await stock.FirstAsync(m => m.SkuNo == l.SkuNo && m.LotNo == l.LotNo);
			if (de == null)
			{
			throw new Exception($"未查询到物料{l.SkuNo}批次{l.LotNo}的总库存的信息");
			throw Oops.Bah($"未查询到物料{l.SkuNo}批次{l.LotNo}的总库存的信息");
			}
			de.Qty -= de3.Qty;
			de.LockQty -= de3.Qty;

			Db.Updateable(de).ExecuteCommand();
			await Db.Updateable(de).ExecuteCommandAsync();
			}
			}
			//将盘点明细状态改为已调整
			d.Status = 4;
			d.UpdateTime = time;
			d.UpdateUser = userId;
			d.UpdateUser = _userManager.UserId;

			Db.Updateable(d).ExecuteCommand();
			await Db.Updateable(d).ExecuteCommandAsync();
			}
			//将盘点总表状态改为生成调整
			notice.Status = 3;
			notice.UpdateTime = time;
			notice.UpdateUser = userId;
			Db.Updateable(notice).ExecuteCommand();
			notice.UpdateUser = _userManager.UserId;
			await Db.Updateable(notice).ExecuteCommandAsync();
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "调整单据", $"调整了单据号为{notice.CRNo}的盘点单信息", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", notice.CRNo, "调整单据", $"调整了单据号为{notice.CRNo}的盘点单信息", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = notice.CRNo,
			TypeName = "调整单据",
			Msg = $"调整了单据号为{notice.CRNo}的盘点单信息"
			});
			//提交事务
			Db.CommitTran();
			return true;
			}
			catch (Exception e)
			{
			@@ -897,343 +888,727 @@
			}

			//盘点下发出库
			public List<OutCommandDto> CheckOutHouse(string crNo, string outMode, int userId, string url, out string str)
			public async Task<List<OutCommandDto>> CheckOutHouse(string crNo, string outMode, string url, string str)
			{
			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 = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.CRNo == crNo && m.IsDel == "0");
			if (notice == null)
			{
			#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<BllStockCheck>().First(m => m.CRNo == crNo && m.IsDel == "0");
			if (notice == null)
			throw Oops.Bah($"未找到{crNo}盘点单信息");
			}
			//所有要出库的盘点明细信息(等待的信息和待拣货的信息)
			var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "InventoryCheckMethod");
			if (funSetting == null \|\| funSetting.IsEnable == "OFF")
			{
			throw Oops.Bah("需配置盘点方式");
			}
			var list = await Db.Queryable<BllStockCheckDetail>().Where(a => a.IsDel == "0" && a.CRNo == crNo && (a.Status == 0 \|\| a.Status == 1 \|\| a.Status == 2)).ToListAsync();
			if (list.Count == 0) //判断是否有需要下发的盘点明细
			{
			throw Oops.Bah("当前盘点单据无需要下发的托盘");
			}
			if (funSetting.SetValue == "once")
			{
			if (list.Any(s => s.Status == 1 \|\| s.Status == 2))
			{
			throw new Exception($"未找到{crNo}盘点单信息");
			throw Oops.Bah("已有正在出库或待盘点的数据，请完成盘点后再出库");
			}
			//所有要出库的盘点明细信息(等待的信息和待拣货的信息)
			var list = Db.Queryable<BllStockCheckDetail>().Where(a => a.IsDel == "0" && a.CRNo == crNo && a.Status == 0).ToList();
			if (list.Count == 0) //判断是否有需要下发的盘点明细
			list = new List<BllStockCheckDetail>() { list.FirstOrDefault() };
			}
			else
			{
			list = list.Where(s => s.Status == 0).ToList();
			}
			#region
			//要出库的托盘集合
			var outLpnList = list.Select(m => m.PalletNo).Distinct().ToList();
			//要出库的明细集合
			var outStockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToListAsync();
			var outStockBox = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToListAsync();
			//获取物料信息
			var skuNo = await Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0" && a.Type == "4").Select(a => a.SkuNo).ToListAsync();
			var time = DateTime.Now;
			//Db.BeginTran();
			//循环盘点明细的信息生成出库任务
			foreach (var item in list)
			{
			if (item.Status == 0)
			{
			throw new Exception("当前盘点单据无需要下发的托盘");
			}
			#region
			//要出库的托盘集合
			var outLpnList = list.Select(m => m.PalletNo).Distinct().ToList();
			//要出库的明细集合
			var outStockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToList();
			var outStockBox = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToList();
			//获取物料信息
			var skuNo = Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0" && a.Type == "4").Select(a => a.SkuNo).ToList();
			var time = DateTime.Now;
			Db.BeginTran();
			try
			{
			//循环盘点明细的信息生成出库任务
			foreach (var item in list)
			var logList = new List<BllStockCheckLog>();
			//判断是否为无码物料
			if (skuNo.Contains(item.SkuNo))
			{
			if (item.Status == 0)
			var de = outStockDetail.First(m => m.IsDel == "0" &&
			m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo);

			var checkLog = new BllStockCheckLog()
			{
			var logList = new List<BllStockCheckLog>();
			//判断是否为无码物料
			if (skuNo.Contains(item.SkuNo))
			{
			var de = outStockDetail.First(m => m.IsDel == "0" &&
			m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo);
			CRNo = item.CRNo,
			PalletNo = item.PalletNo,
			BoxNo = "",
			BoxNo2 = "",
			BoxNo3 = "",
			Qty = (int?)de.Qty,
			SkuNo = de.SkuNo,
			SkuName = de.SkuName,
			Standard = de.Standard,
			LotNo = de.LotNo,
			LotText = de.LotText,
			SupplierLot = de.SupplierLot,

			var checkLog = new BllStockCheckLog()
			{
			CRNo = item.CRNo,
			PalletNo = item.PalletNo,
			BoxNo = "",
			BoxNo2 = "",
			BoxNo3 = "",
			Qty = (int?)de.Qty,
			SkuNo = de.SkuNo,
			SkuName = de.SkuName,
			Standard = de.Standard,
			LotNo = de.LotNo,
			LotText = de.LotText,
			SupplierLot = de.SupplierLot,
			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			logList.Add(checkLog);

			CreateUser = userId,
			CreateTime = time
			};
			logList.Add(checkLog);

			}
			else
			{
			var de = outStockDetail.Where(m =>
			m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo).Select(m => m.Id).ToList();
			var bo = outStockBox.Where(m => de.Contains(m.StockDetailId)).ToList();
			foreach (var b in bo)
			{
			var checkLog = new BllStockCheckLog()
			{
			CRNo = item.CRNo,
			PalletNo = item.PalletNo,
			BoxNo = b.BoxNo,
			BoxNo2 = b.BoxNo2,
			BoxNo3 = b.BoxNo3,
			Qty = b.Qty,
			SkuNo = b.SkuNo,
			SkuName = b.SkuName,
			Standard = b.Standard,
			LotNo = b.LotNo,
			LotText = b.LotText,
			SupplierLot = b.SupplierLot,

			CreateUser = userId,
			CreateTime = time
			};
			logList.Add(checkLog);
			}
			}

			//生成盘点记录
			Db.Insertable(logList).ExecuteCommand();
			}
			// 储位号
			var locateNo = outStockDetail.First(m => m.PalletNo == item.PalletNo && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo).LocatNo;

			#region 判断
			//判断托盘是否在库内
			if (string.IsNullOrWhiteSpace(locateNo))
			}
			else
			{
			var de = outStockDetail.Where(m =>
			m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo).Select(m => m.Id).ToList();
			var bo = outStockBox.Where(m => de.Contains(m.StockDetailId)).ToList();
			foreach (var b in bo)
			{
			var de = outStockDetail.First(m => m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo);
			//判断是否是零箱库，当前明细信息直接更新出库完成
			if (de != null && de.WareHouseNo == "W02")
			var checkLog = new BllStockCheckLog()
			{
			//盘点明细状态改为待盘点
			item.Status = 2;
			Db.Updateable(item).ExecuteCommand();
			//盘点信息修改
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = userId;
			notice.UpdateTime = time;
			Db.Updateable(notice).ExecuteCommand();
			}
			//库存中当前托盘的信息
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == item.PalletNo).ToList();
			foreach (var s in stockDetail)
			{
			s.LocatNo = "";//储位更改（改为空）
			s.WareHouseNo = "";//所属仓库更改（改为空）
			s.RoadwayNo = "";//所属巷道更改（改为空）
			s.AreaNo = "";//所属区域更改（改为空）
			Db.Updateable(s).ExecuteCommand();
			}
			flagList.Add(5);
			continue;
			}
			//判断托盘是否在入库中
			var imBl = com.GetImTask(item.PalletNo);
			if (imBl != null)
			{
			flagList.Add(4);
			continue;
			}
			//判断是否是已经出过库又回库（状态为待拣货的 1）
			if (item.Status == 0)
			{
			//如果不在仓库内，当前明细信息直接更新出库完成
			item.Status = 2;//状态
			Db.Updateable(item).ExecuteCommand();
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = userId;
			notice.UpdateTime = time;
			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成功
			CRNo = item.CRNo,
			PalletNo = item.PalletNo,
			BoxNo = b.BoxNo,
			BoxNo2 = b.BoxNo2,
			BoxNo3 = b.BoxNo3,
			Qty = b.Qty,
			SkuNo = b.SkuNo,
			SkuName = b.SkuName,
			Standard = b.Standard,
			LotNo = b.LotNo,
			LotText = b.LotText,
			SupplierLot = b.SupplierLot,

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

			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			Db.Insertable(exTask).ExecuteCommand();

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

			#region 改变数据
			if (item.Status == 0)//判断托盘是否下发过
			{
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = userId;
			notice.UpdateTime = time;
			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)
			{
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = userId;
			notice.UpdateTime = time;
			Db.Updateable(notice).ExecuteCommand();

			}
			}
			var taskNo = Db.Queryable<LogTask>().First(m => m.OrderType == "2" && 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);
			logList.Add(checkLog);
			}
			}
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", crNo, "出库", $"点击出库按钮盘点单号为：{crNo}的盘点单", 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 (flagList.Count(m => m == 5) > 0)
			{
			str += "5.要出库的托盘在零箱库、";
			}
			if (outDtoList.Count > 0)
			{
			// 正式运行程序放开
			var list2 = outDtoList.Select(m => m.TaskNo).ToList();
			var jsonData = JsonConvert.SerializeObject(outDtoList);
			string response = "";

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

			////解析返回数据
			//var wcsModel = JsonConvert.DeserializeObject<WcsModel>(response);
			//if (wcsModel.StatusCode == 0)
			//{
			// //更改任务的发送返回时间//
			// new TaskServer().EditTaskIssueOk(list2, time1, time2);
			//str += "下发成功";
			//}
			//if (wcsModel.StatusCode == -1)
			//{
			// new TaskServer().EditTaskIssueNo(list2, time1, time2, wcsModel.Msg);
			// throw new Exception(wcsModel.Msg);
			//}
			}
			catch (Exception ex)
			{
			throw new Exception(ex.Message);
			}
			}
			return outDtoList;
			//生成盘点记录
			await Db.Insertable(logList).ExecuteCommandAsync();
			}
			catch (Exception e)
			// 储位号
			var locateNo = outStockDetail.First(m => m.PalletNo == item.PalletNo && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo).LocatNo;

			#region 判断
			//判断托盘是否在库内
			if (string.IsNullOrWhiteSpace(locateNo))
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			var de = outStockDetail.First(m => m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo);
			//判断是否是零箱库，当前明细信息直接更新出库完成
			if (de != null && de.WareHouseNo == "W02")
			{
			//盘点明细状态改为待盘点
			item.Status = 2;
			await Db.Updateable(item).ExecuteCommandAsync();
			//盘点信息修改
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			//库存中当前托盘的信息
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == item.PalletNo).ToListAsync();
			foreach (var s in stockDetail)
			{
			s.LocatNo = "";//储位更改（改为空）
			s.WareHouseNo = "";//所属仓库更改（改为空）
			s.RoadwayNo = "";//所属巷道更改（改为空）
			s.AreaNo = "";//所属区域更改（改为空）
			await Db.Updateable(s).ExecuteCommandAsync();
			}
			flagList.Add(5);
			continue;
			}
			//判断托盘是否在入库中
			var imBl = com.GetImTask(item.PalletNo);
			if (imBl != null)
			{
			flagList.Add(4);
			continue;
			}
			//判断是否是已经出过库又回库（状态为待拣货的 1）
			if (item.Status == 0)
			{
			//如果不在仓库内，当前明细信息直接更新出库完成
			item.Status = 2;//状态
			await Db.Updateable(item).ExecuteCommandAsync();
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			}
			continue;
			}
			//当前出库的储位信息
			var locate = await Db.Queryable<SysStorageLocat>().FirstAsync(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 = outMode,//目标位置
			PalletNo = item.PalletNo,//托盘码
			IsSend = 1,//是否可再次下发
			IsCancel = 1,//是否可取消
			IsFinish = 1,//是否可完成
			Type = "1",//任务类型 0 入库任务 1 出库任务 2 移库任务
			Status = "0",//任务状态0：等待执行1正在执行2执行完成
			OrderType = "2",//0 入库单 1 出库单 2 盘点单 3 移库单

			CreateTime = time
			};
			await Db.Insertable(exTask).ExecuteCommandAsync();

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

			#region 改变数据
			if (item.Status == 0)//判断托盘是否下发过
			{
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			}
			locate.Status = "3"; //要出库的储位改变状态正在出库
			await Db.Updateable(locate).ExecuteCommandAsync();

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

			flagList.Add(0);
			}
			else if (locate.Status == "3") //出库中
			{
			#region 改变数据
			//判断是否是已经出过库又回库（状态为待拣货的 1）
			if (item.Status == 0)
			{
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();

			}
			}
			var taskNo = Db.Queryable<LogTask>().First(m => m.OrderType == "2" && m.TaskNo != item.TaskNo && m.Status == "1" && m.PalletNo == item.PalletNo);
			item.TaskNo = taskNo.TaskNo;
			item.Status = 1; // 出库分配信息状态改为正在执行
			await Db.Updateable(item).ExecuteCommandAsync();

			#endregion
			}
			else if (locate.Status == "5") //移出中
			{
			flagList.Add(1);
			}
			}
			catch (Exception e)
			//添加操作日志记录
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", crNo, "出库", $"点击出库按钮盘点单号为：{crNo}的盘点单", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			throw new Exception(e.Message);
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = crNo,
			TypeName = "出库",
			Msg = $"点击出库按钮盘点单号为：{crNo}的盘点单"
			});
			//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 += "3.储位损坏不能出库、";
			}
			if (flagList.Count(m => m == 4) > 0)
			{
			str += "4.要出库的托盘正在入库、";
			}
			if (flagList.Count(m => m == 5) > 0)
			{
			str += "5.要出库的托盘在零箱库、";
			}
			if (!string.IsNullOrEmpty(str))
			throw Oops.Bah(str);
			if (outDtoList.Count > 0)
			{
			// 正式运行程序放开
			var list2 = outDtoList.Select(m => m.TaskNo).ToList();
			var jsonData = JsonConvert.SerializeObject(outDtoList);
			string response = "";

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

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

			/// <summary>
			/// 视觉盘点
			/// </summary>
			/// <param name="crNo"></param>
			/// <param name="url"></param>
			/// <param name="str"></param>
			/// <returns></returns>
			public async Task<List<OutCommandDto>> CheckVision(string crNo, string url, string str)
			{
			#region 集合
			var outDtoList = new List<OutCommandDto>(); //出库数据的集合
			//记录错误信息的集合
			var flagList = new List<int>();//1:当前要出库的储位正在移出、2 出库的托盘储位信息错误(在储位表中未查询到)、3储位损坏不能出库、4 要出库的托盘正在入库

			#endregion
			var com = new Common();
			//assign.IsHavePyTask();
			var notice = await Db.Queryable<BllStockCheck>().FirstAsync(m => m.CRNo == crNo && m.IsDel == "0");
			if (notice == null)
			{
			throw Oops.Bah($"未找到{crNo}盘点单信息");
			}
			//所有要出库的盘点明细信息(等待的信息和待拣货的信息)
			var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "InventoryCheckMethod");
			if (funSetting == null \|\| funSetting.IsEnable == "OFF")
			{
			throw Oops.Bah("需配置盘点方式");
			}
			var list = await Db.Queryable<BllStockCheckDetail>().Where(a => a.IsDel == "0" && a.CRNo == crNo && (a.Status == 0 \|\| a.Status == 1 \|\| a.Status == 2)).ToListAsync();
			if (list.Count == 0) //判断是否有需要下发的盘点明细
			{
			throw Oops.Bah("当前盘点单据无需要下发的托盘");
			}
			if (funSetting.SetValue == "once")
			{
			if (list.Any(s => s.Status == 1 \|\| s.Status == 2))
			{
			throw Oops.Bah("已有正在出库或待盘点的数据，请完成盘点后再出库");
			}
			list = new List<BllStockCheckDetail>() { list.FirstOrDefault() };
			}
			else
			{
			list = list.Where(s => s.Status == 0).ToList();
			}
			#region
			//要出库的托盘集合
			var outLpnList = list.Select(m => m.PalletNo).Distinct().ToList();
			//要出库的明细集合
			var outStockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToListAsync();
			var outStockBox = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && outLpnList.Contains(m.PalletNo)).ToListAsync();
			//获取物料信息
			var skuNo = await Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0" && a.Type == "4").Select(a => a.SkuNo).ToListAsync();
			var time = DateTime.Now;
			//Db.BeginTran();
			//循环盘点明细的信息生成出库任务
			foreach (var item in list)
			{
			if (item.Status == 0)
			{
			var logList = new List<BllStockCheckLog>();
			//判断是否为无码物料
			if (skuNo.Contains(item.SkuNo))
			{
			var de = outStockDetail.First(m => m.IsDel == "0" &&
			m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo);

			var checkLog = new BllStockCheckLog()
			{
			CRNo = item.CRNo,
			PalletNo = item.PalletNo,
			BoxNo = "",
			BoxNo2 = "",
			BoxNo3 = "",
			Qty = (int?)de.Qty,
			SkuNo = de.SkuNo,
			SkuName = de.SkuName,
			Standard = de.Standard,
			LotNo = de.LotNo,
			LotText = de.LotText,
			SupplierLot = de.SupplierLot,

			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			logList.Add(checkLog);

			}
			else
			{
			var de = outStockDetail.Where(m =>
			m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo).Select(m => m.Id).ToList();
			var bo = outStockBox.Where(m => de.Contains(m.StockDetailId)).ToList();
			foreach (var b in bo)
			{
			var checkLog = new BllStockCheckLog()
			{
			CRNo = item.CRNo,
			PalletNo = item.PalletNo,
			BoxNo = b.BoxNo,
			BoxNo2 = b.BoxNo2,
			BoxNo3 = b.BoxNo3,
			Qty = b.Qty,
			SkuNo = b.SkuNo,
			SkuName = b.SkuName,
			Standard = b.Standard,
			LotNo = b.LotNo,
			LotText = b.LotText,
			SupplierLot = b.SupplierLot,

			CreateUser = _userManager.UserId,
			CreateTime = time
			};
			logList.Add(checkLog);
			}
			}

			//生成盘点记录
			await Db.Insertable(logList).ExecuteCommandAsync();
			}
			// 储位号
			var locateNo = outStockDetail.First(m => m.PalletNo == item.PalletNo && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo).LocatNo;

			#region 判断
			//判断托盘是否在库内
			if (string.IsNullOrWhiteSpace(locateNo))
			{
			var de = outStockDetail.First(m => m.SkuNo == item.SkuNo && m.LotNo == item.LotNo && m.PalletNo == item.PalletNo);
			//判断是否是零箱库，当前明细信息直接更新出库完成
			if (de != null && de.WareHouseNo == "W02")
			{
			//盘点明细状态改为待盘点
			item.Status = 2;
			await Db.Updateable(item).ExecuteCommandAsync();
			//盘点信息修改
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			//库存中当前托盘的信息
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == item.PalletNo).ToListAsync();
			foreach (var s in stockDetail)
			{
			s.LocatNo = "";//储位更改（改为空）
			s.WareHouseNo = "";//所属仓库更改（改为空）
			s.RoadwayNo = "";//所属巷道更改（改为空）
			s.AreaNo = "";//所属区域更改（改为空）
			await Db.Updateable(s).ExecuteCommandAsync();
			}
			flagList.Add(5);
			continue;
			}
			//判断托盘是否在入库中
			var imBl = com.GetImTask(item.PalletNo);
			if (imBl != null)
			{
			flagList.Add(4);
			continue;
			}
			//判断是否是已经出过库又回库（状态为待拣货的 1）
			if (item.Status == 0)
			{
			//如果不在仓库内，当前明细信息直接更新出库完成
			item.Status = 2;//状态
			await Db.Updateable(item).ExecuteCommandAsync();
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			}
			continue;
			}
			//当前出库的储位信息
			var locate = await Db.Queryable<SysStorageLocat>().FirstAsync(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 = outMode,//目标位置
			PalletNo = item.PalletNo,//托盘码
			IsSend = 1,//是否可再次下发
			IsCancel = 1,//是否可取消
			IsFinish = 1,//是否可完成
			Type = "1",//任务类型 0 入库任务 1 出库任务 2 移库任务
			Status = "0",//任务状态0：等待执行1正在执行2执行完成
			OrderType = "6",////0 入库单 1 出库单 2 盘点单 3 移库单 4 取样出库单 6视觉盘点
			Msg = $"{locateNo}的视觉盘点任务",
			CreateTime = time
			};
			await Db.Insertable(exTask).ExecuteCommandAsync();

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

			#region 改变数据
			if (item.Status == 0)//判断托盘是否下发过
			{
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			}
			//locate.Status = "3"; //要出库的储位改变状态正在出库
			await Db.Updateable(locate).ExecuteCommandAsync();

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

			flagList.Add(0);
			}
			else if (locate.Status == "3") //出库中
			{
			#region 改变数据
			//判断是否是已经出过库又回库（状态为待拣货的 1）
			if (item.Status == 0)
			{
			if (notice.Status == 0)
			{
			notice.CheckDate = DateTime.Now;
			notice.Status = 1;
			notice.UpdateUser = _userManager.UserId;
			notice.UpdateTime = time;
			await Db.Updateable(notice).ExecuteCommandAsync();

			}
			}
			var taskNo = Db.Queryable<LogTask>().First(m => m.OrderType == "2" && m.TaskNo != item.TaskNo && m.Status == "1" && m.PalletNo == item.PalletNo);
			item.TaskNo = taskNo.TaskNo;
			item.Status = 1; // 出库分配信息状态改为正在执行
			await Db.Updateable(item).ExecuteCommandAsync();

			#endregion
			}
			else if (locate.Status == "5") //移出中
			{
			flagList.Add(1);
			}
			}
			//添加操作日志记录
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "盘点单据", crNo, "出库", $"点击出库按钮盘点单号为：{crNo}的盘点单", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "盘点单据",
			FkNo = crNo,
			TypeName = "出库",
			Msg = $"点击出库按钮盘点单号为：{crNo}的盘点单"
			});
			//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 += "3.储位损坏不能出库、";
			}
			if (flagList.Count(m => m == 4) > 0)
			{
			str += "4.要出库的托盘正在入库、";
			}
			if (flagList.Count(m => m == 5) > 0)
			{
			str += "5.要出库的托盘在零箱库、";
			}
			if (!string.IsNullOrEmpty(str))
			throw Oops.Bah(str);
			if (outDtoList.Count > 0)
			{
			// 正式运行程序放开
			var list2 = outDtoList.Select(m => m.TaskNo).ToList();
			var jsonData = JsonConvert.SerializeObject(outDtoList);
			string response = "";

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

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

			/// <summary>
			/// 视觉盘点传结果
			/// </summary>
			/// <param name="crNo"></param>
			/// <param name="url"></param>
			/// <param name="str"></param>
			/// <returns></returns>
			public async Task CheckVision(CheckVm model)
			{
			if (string.IsNullOrWhiteSpace(model.CrNo))
			{
			throw Oops.Bah("盘点单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(model.SkuNo))
			{
			throw Oops.Bah("物料不能为空");
			}
			if (string.IsNullOrWhiteSpace(model.LotNo))
			{
			throw Oops.Bah("物料批次不能为空");
			}
			if (string.IsNullOrWhiteSpace(model.PalletNo))
			{
			throw Oops.Bah("托盘码不能为空");
			}
			//盘点明细
			var checkDetail = await Db.Queryable<BllStockCheckDetail>().FirstAsync(m =>
			m.IsDel == "0" && m.CRNo == model.CrNo && m.PalletNo == model.PalletNo && m.SkuNo == model.SkuNo && m.LotNo == model.LotNo);
			if (checkDetail == null)
			{
			throw Oops.Bah("未查询到未盘点的盘点明细信息");
			}
			var modSku = await Db.Queryable<SysMaterials>().Where(s => s.SkuNo == model.SkuNo).FirstAsync();

			}
			//盘点出库完成
			public void CheckSuccess(string taskNo, int userId)
			public async Task CheckSuccess(string taskNo, int userId)
			{
			try
			{
			@@ -1241,48 +1616,59 @@
			var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
			if (task == null)
			{
			throw new Exception($"未查询到任务号为：‘{taskNo}’的任务信息");
			throw Oops.Bah($"未查询到任务号为：‘{taskNo}’的任务信息");
			}
			if (task.Status == "2")
			{
			throw new Exception("当前任务已完成");
			throw Oops.Bah("当前任务已完成");
			}
			Db.BeginTran();
			//库存中当前托盘的信息
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToListAsync();
			var locateNo = stockDetail.Select(m => m.LocatNo).Distinct().FirstOrDefault();
			//当前任务中的储位信息
			var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo);
			var locate = await Db.Queryable<SysStorageLocat>().FirstAsync(m => m.LocatNo == locateNo);

			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)
			await Db.Updateable(task).ExecuteCommandAsync();
			if(task.OrderType != "6")//视觉盘点不更改状态
			{
			item.LocatNo = "";//储位更改（改为空）
			item.WareHouseNo = "";//所属仓库更改（改为空）
			item.RoadwayNo = "";//所属巷道更改（改为空）
			item.AreaNo = "";//所属区域更改（改为空）
			Db.Updateable(item).ExecuteCommand();
			locate.Status = "0"; // 更改当前任务中的储位状态（改为0空储位）
			await Db.Updateable(locate).ExecuteCommandAsync();
			foreach (var item in stockDetail)
			{
			item.LocatNo = "";//储位更改（改为空）
			item.WareHouseNo = "";//所属仓库更改（改为空）
			item.RoadwayNo = "";//所属巷道更改（改为空）
			item.AreaNo = "";//所属区域更改（改为空）
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}
			//盘点明细（更改状态）
			var checkDetails = Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && (m.TaskNo == taskNo \|\| (m.Status == 1 && m.PalletNo == task.PalletNo))).ToList();
			var checkDetails = await Db.Queryable<BllStockCheckDetail>().Where(m => m.IsDel == "0" && (m.TaskNo == taskNo \|\| (m.Status == 1 && m.PalletNo == task.PalletNo))).ToListAsync();

			foreach (var item in checkDetails)
			{
			item.Status = 2;
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}

			if (userId != 0)
			if (_userManager.UserId != 0)
			{
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "库内日志",
			FkNo = taskNo,
			TypeName = "完成",
			Msg = $"点击完成按钮、完成任务号为：{taskNo}的任务"
			});
			}
			Db.CommitTran();

			@@ -1295,27 +1681,27 @@
			}

			//AGV移库完成
			public void MoveSuccess(string taskNo, int userId)
			public async Task MoveSuccess(string taskNo)
			{
			try
			{
			//当前任务信息
			var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
			var task = await Db.Queryable<LogTask>().FirstAsync(m => m.TaskNo == taskNo && m.IsDel == "0");
			if (task == null)
			{
			throw new Exception($"未查询到任务号为：‘{taskNo}’的任务信息");
			throw Oops.Bah($"未查询到任务号为：‘{taskNo}’的任务信息");
			}
			if (task.Status == "2")
			{
			throw new Exception("当前任务已完成");
			throw Oops.Bah("当前任务已完成");
			}
			Db.BeginTran();
			//库存中当前托盘的信息
			var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToListAsync();
			var locateNo = stockDetail.Select(m => m.LocatNo).Distinct().FirstOrDefault();


			//当前任务中的储位信息
			var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo);
			var locate = await Db.Queryable<SysStorageLocat>().FirstAsync(m => m.LocatNo == locateNo);

			//更改任务
			task.Status = "2";//任务状态
			@@ -1325,16 +1711,16 @@
			task.FinishDate = DateTime.Now;//完成时间
			Db.Updateable(task).ExecuteCommand();
			// 更改当前任务中的储位状态（改为0空储位）
			locate.Status = "0";
			locate.Status = "0";
			Db.Updateable(locate).ExecuteCommand();

			//目标储位信息
			var endLocate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
			var endLocate = await Db.Queryable<SysStorageLocat>().FirstAsync(m => m.LocatNo == task.EndLocat);
			if (endLocate != null)
			{
			if (endLocate.Status != "0")
			{
			throw new Exception("目标储位状态非空储位");
			throw Oops.Bah("目标储位状态非空储位");
			}
			}
			//更改库存明细
			@@ -1355,25 +1741,33 @@
			item.WareHouseNo = "";//所属仓库更改（改为空）
			item.RoadwayNo = "";//所属巷道更改（改为空）
			item.AreaNo = "";//所属区域更改（改为空）
			}
			Db.Updateable(item).ExecuteCommand();
			}
			await Db.Updateable(item).ExecuteCommandAsync();

			//更改库存总表
			var stock = Db.Queryable<DataStock>().First(w => w.IsDel == "0" && w.SkuNo == item.SkuNo && w.LotNo == item.LotNo);
			stock.LockQty -= (decimal)item.Qty;
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}
			if (endLocate != null)
			{
			//更改目标储位状态
			endLocate.Status = "1";//有物品
			Db.Updateable(endLocate).ExecuteCommand();
			await Db.Updateable(endLocate).ExecuteCommandAsync();
			}

			if (userId != 0)
			if (_userManager.UserId != 0)
			{
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "库内日志",
			FkNo = taskNo,
			TypeName = "完成",
			Msg = $"点击完成按钮、完成任务号为：{taskNo}的任务"
			});
			}
			Db.CommitTran();

			@@ -1386,19 +1780,19 @@
			}

			//重新下发盘点出库任务
			public OutCommandDto AgainSendCheckTask(string taskNo, int userId, string url)
			public async Task<OutCommandDto> AgainSendCheckTask(string taskNo, string url)
			{
			try
			{
			var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
			var task = await Db.Queryable<LogTask>().FirstAsync(m => m.TaskNo == taskNo && m.IsDel == "0");
			if (task == null)
			{
			throw new Exception("未查询到任务信息");
			throw Oops.Bah("未查询到任务信息");
			}
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.PalletNo == task.PalletNo);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.PalletNo == task.PalletNo);
			if (stockDetail == null)
			{
			throw new Exception(task.PalletNo + " 当前托盘未在库内，请核实信息");
			throw Oops.Bah(task.PalletNo + " 当前托盘未在库内，请核实信息");
			}
			Db.BeginTran();
			var locateNo = task.StartLocat;
			@@ -1407,13 +1801,13 @@
			{
			locateNo = stockDetail.LocatNo;
			task.StartLocat = locateNo;
			Db.Updateable(task).ExecuteCommand();
			await Db.Updateable(task).ExecuteCommandAsync();
			}
			var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo);
			if (locate != null && locate.Status != "3")
			{
			locate.Status = "3";
			Db.Updateable(locate).ExecuteCommand();
			await Db.Updateable(locate).ExecuteCommandAsync();
			}
			var outDto = new OutCommandDto()
			{
			@@ -1427,7 +1821,15 @@
			Order = 1
			}; //出库数据
			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "下发", $"点击下发按钮、重新下发了任务号为：{taskNo}的任务", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "下发", $"点击下发按钮、重新下发了任务号为：{taskNo}的任务", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "库内日志",
			FkNo = taskNo,
			TypeName = "下发",
			Msg = $"点击下发按钮、重新下发了任务号为：{taskNo}的任务"
			});
			Db.CommitTran();
			// 正式运行程序放开
			var list = new List<string> { outDto.TaskNo };
			@@ -1468,17 +1870,17 @@
			}

			//取消盘点出库任务
			public void CancelCheckTask(string taskNo, int userId)
			public async Task CancelCheckTask(string taskNo)
			{
			try
			{
			Db.BeginTran();
			try
			{
			var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
			var task = await Db.Queryable<LogTask>().FirstAsync(m => m.TaskNo == taskNo && m.IsDel == "0");
			if (task == null)
			{
			throw new Exception("未查询到任务信息");
			throw Oops.Bah("未查询到任务信息");
			}
			//修改任务
			task.IsSuccess = 0;
			@@ -1487,37 +1889,45 @@
			task.IsFinish = 0;
			task.Status = "4";
			task.CancelDate = DateTime.Now;
			Db.Updateable(task).ExecuteCommand();
			await Db.Updateable(task).ExecuteCommandAsync();

			//修改盘点明细
			var checkDetail = Db.Queryable<BllStockCheckDetail>().First(w => w.TaskNo == task.TaskNo);
			var checkDetail = await Db.Queryable<BllStockCheckDetail>().FirstAsync(w => w.TaskNo == task.TaskNo);
			if (checkDetail == null)
			{
			throw new Exception("未查询到盘点明细信息，请核实！");
			throw Oops.Bah("未查询到盘点明细信息，请核实！");
			}
			checkDetail.Status = 0;
			checkDetail.TaskNo = "";
			Db.Updateable(checkDetail).ExecuteCommand();
			await Db.Updateable(checkDetail).ExecuteCommandAsync();

			//修改盘点记录
			var checkLog = Db.Queryable<BllStockCheckLog>().First(w => w.CRNo == checkDetail.CRNo && w.PalletNo == checkDetail.PalletNo && w.IsDel == "0");
			var checkLog = await Db.Queryable<BllStockCheckLog>().FirstAsync(w => w.CRNo == checkDetail.CRNo && w.PalletNo == checkDetail.PalletNo && w.IsDel == "0");
			if (checkLog == null)
			{
			throw new Exception("未查询到盘点记录信息，请核实！");
			throw Oops.Bah("未查询到盘点记录信息，请核实！");
			}
			checkLog.IsDel = "1";
			Db.Updateable(checkLog).ExecuteCommand();
			await Db.Updateable(checkLog).ExecuteCommandAsync();
			//修改储位信息
			var locat = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.WareHouseNo == "W02" && a.LocatNo == task.StartLocat);
			var locat = await Db.Queryable<SysStorageLocat>().FirstAsync(a => a.IsDel == "0" && a.WareHouseNo == "W02" && a.LocatNo == task.StartLocat);
			if (locat == null)
			{
			throw new Exception("未查询到储位信息，请核实！");
			throw Oops.Bah("未查询到储位信息，请核实！");
			}
			locat.Status = "1"; //有物品
			Db.Updateable(locat).ExecuteCommand();
			await Db.Updateable(locat).ExecuteCommandAsync();

			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "取消", $"点击取消按钮、取消了任务号为：{taskNo}的任务", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "取消", $"点击取消按钮、取消了任务号为：{taskNo}的任务", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "库内日志",
			FkNo = taskNo,
			TypeName = "取消",
			Msg = $"点击取消按钮、取消了任务号为：{taskNo}的任务"
			});
			Db.CommitTran();
			}
			catch (Exception e)
			@@ -1533,16 +1943,16 @@
			}

			//取消AGV移库任务
			public void CancelMoveTask(string taskNo, int userId)
			public async Task CancelMoveTask(string taskNo)
			{
			try
			{
			Db.BeginTran();

			var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
			var task = await Db.Queryable<LogTask>().FirstAsync(m => m.TaskNo == taskNo && m.IsDel == "0");
			if (task == null)
			{
			throw new Exception("未查询到任务信息");
			throw Oops.Bah("未查询到任务信息");
			}
			//修改任务
			task.IsSuccess = 0;
			@@ -1551,46 +1961,54 @@
			task.IsFinish = 0;
			task.Status = "4";
			task.CancelDate = DateTime.Now;
			Db.Updateable(task).ExecuteCommand();
			await Db.Updateable(task).ExecuteCommandAsync();

			//修改起始储位信息
			var locat = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.WareHouseNo == "W02" && a.LocatNo == task.StartLocat);
			var locat = await Db.Queryable<SysStorageLocat>().FirstAsync(a => a.IsDel == "0" && a.WareHouseNo == "W02" && a.LocatNo == task.StartLocat);
			if (locat == null)
			{
			throw new Exception("未查询到储位信息，请核实！");
			throw Oops.Bah("未查询到储位信息，请核实！");
			}
			locat.Status = "1"; //有物品
			Db.Updateable(locat).ExecuteCommand();

			//修改目标储位信息
			var locatEnd = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.WareHouseNo == "W02" && a.LocatNo == task.EndLocat);
			var locatEnd = await Db.Queryable<SysStorageLocat>().FirstAsync(a => a.IsDel == "0" && a.WareHouseNo == "W02" && a.LocatNo == task.EndLocat);
			if (locatEnd != null)
			{
			locatEnd.Status = "0"; //空储位
			Db.Updateable(locatEnd).ExecuteCommand();
			}
			await Db.Updateable(locatEnd).ExecuteCommandAsync();
			}

			//修改库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(w => w.IsDel == "0" && w.PalletNo == task.PalletNo);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(w => w.IsDel == "0" && w.PalletNo == task.PalletNo);
			if (stockDetail == null)
			{
			throw new Exception("托盘上物料库存明细信息不存在,请检查!");
			throw Oops.Bah("托盘上物料库存明细信息不存在,请检查!");
			}
			stockDetail.Status = "0";//待分配
			stockDetail.LockQty = 0;//锁定数量
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();

			//修改库存
			var stock = Db.Queryable<DataStock>().First(w => w.IsDel == "0" && w.SkuNo == stockDetail.SkuNo && w.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(w => w.IsDel == "0" && w.SkuNo == stockDetail.SkuNo && w.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("托盘上物料库存信息不存在,请检查!");
			throw Oops.Bah("托盘上物料库存信息不存在,请检查!");
			}
			stock.LockQty -= (decimal)stockDetail.Qty;
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();

			//添加操作日志记录
			var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "取消", $"点击取消按钮、取消了任务号为：{taskNo}的任务", userId);
			//var k = new OperationCrServer().AddLogOperationCr("库内作业", "库内日志", taskNo, "取消", $"点击取消按钮、取消了任务号为：{taskNo}的任务", userId);
			await _operation.AddLogOperationCr(new OperationInputVm()
			{
			ParentName = "库内作业",
			MenuName = "库内日志",
			FkNo = taskNo,
			TypeName = "取消",
			Msg = $"点击取消按钮、取消了任务号为：{taskNo}的任务"
			});
			Db.CommitTran();
			}
			catch (Exception e)