using AutoMapper;
using Castle.Core.Internal;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using SqlSugar;
using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using WCS.Entity.fj;
using wms.dataservice.IDataSetvice;
using wms.dto;
using wms.dto.request;
using wms.dto.request.fj;
using wms.dto.request.share;
using wms.dto.response;
using wms.dto.response.fj;
using wms.service.IService;
using wms.sqlsugar;
using wms.sqlsugar.model;
using wms.sqlsugar.model.fj;
using wms.util.Check;
using wms.util.Ext;

namespace wms.service.Service
{
    /// <summary>
    ///  分拣服务
    /// </summary>
    public class FJService : IFJService
    {
        private readonly IMapper _mapper;
        private readonly ILogger<FJService> _logger;
        private readonly IFJDataService _IFJDataService;

        public FJService(IMapper mapper, ILogger<FJService> logger, IFJDataService IFJDataService)
        {
            _mapper = mapper;
            _logger = logger;
            _IFJDataService = IFJDataService;
        }

        private ITenant _db => SqlSugarHelper.Db;//处理事务

        #region 初始化仓储

        private Repository<fjBillDocument> _docrepository => new Repository<fjBillDocument>();
        private Repository<fjSysConfig> _sysconfigrepository => new Repository<fjSysConfig>();
        private Repository<fjBaseMater> _materrepository => new Repository<fjBaseMater>();
        private Repository<fjBillTask> _billTaskrepository => new Repository<fjBillTask>();
        private Repository<fjBaseWarehouse> _baseWareHouserepository => new Repository<fjBaseWarehouse>();
        private Repository<fjBillBarcode> _billBarcoderepository => new Repository<fjBillBarcode>();
        private Repository<fjBillFeedbackPush> _billFbackPushrepository => new Repository<fjBillFeedbackPush>();
        private Repository<fjBillBomInfo> _fjBillBomInfoRepository => new Repository<fjBillBomInfo>();
        private Repository<fjBillWetStack> _fjBillWetStackRepository => new Repository<fjBillWetStack>();

        /// <summary>
        ///  容器表
        /// </summary>
        private Repository<BaseContinfo> _baseContinfo => new Repository<BaseContinfo>();

        /// <summary>
        ///  当前任务表
        /// </summary>
        private RepositoryTask<WCS_TaskInfo> _taskrepository => new RepositoryTask<WCS_TaskInfo>();

        /// <summary>
        ///  库存表
        /// </summary>
        private Repository<BillInvnow> _billInvnowrepository => new Repository<BillInvnow>();

        /// <summary>
        ///  条码表
        /// </summary>
        private Repository<BillInvinit> _billInvinitrepository => new Repository<BillInvinit>();

        /// <summary>
        ///  物料表
        /// </summary>
        private Repository<BaseMatinfo> _basematerrepository => new Repository<BaseMatinfo>();

        /// <summary>
        ///  码垛工字轮信息
        /// </summary>
        private Repository<BillSpoolTrans> _billSpoolTransrepository => new Repository<BillSpoolTrans>();

        private Repository<BillBominfo> _billBominfoRepository => new Repository<BillBominfo>();

        /// <summary>
        ///  垛形信息
        /// </summary>
        private Repository<BillBomsetinfo> _billBomsetinfoRepository => new Repository<BillBomsetinfo>();

        /// <summary>
        ///  单据表
        /// </summary>
        private Repository<BillDocsinfo> _billdocrepository => new Repository<BillDocsinfo>();

        /// <summary>
        ///  任务历史表
        /// </summary>
        private RepositoryTask<WCS_TaskOld> _wcstaskoldrepository => new RepositoryTask<WCS_TaskOld>();

        /// <summary>
        ///  流水表
        /// </summary>
        private Repository<BillInvflow> _billInvflow => new Repository<BillInvflow>();

        /// <summary>
        ///  甲方管理系统推送反馈
        /// </summary>
        private Repository<BillPushinfo> _billPushinforepository => new Repository<BillPushinfo>();

        /// <summary>
        ///  货位表
        /// </summary>
        private Repository<BaseWarecell> _basewarecellrepository => new Repository<BaseWarecell>();

        /// <summary>
        ///  仓库表
        /// </summary>
        private Repository<BaseWarehouse> _basewarehouserepository => new Repository<BaseWarehouse>();

        private RepositoryTask<WCS_TaskDtl> _taskdetailrepository => new RepositoryTask<WCS_TaskDtl>();

        /// <summary>
        ///  机台表
        /// </summary>
        private Repository<BillMachinfo> _basemachinforepository => new Repository<BillMachinfo>();

        #endregion 初始化仓储

        /// <summary>
        /// 添加单据
        /// </summary>
        /// <returns></returns>
        public bool Add(fjBillDocument data1)
        {
            try
            {
                _db.BeginTran();
                _docrepository.Insert(data1);
                _db.CommitTran();
            }
            catch (Exception)
            {
                _db.RollbackTran();
                throw;
            }
            return true;
        }

        /// <summary>
        /// 获取配置内容信息
        /// </summary>
        /// <param name="code">配置表code值</param>
        /// <returns></returns>
        public string GetSysConfigContentByCode(string code)
        {
            //先读缓存
            var cacheContent = RedisHelper.Get("sys_config" + code);
            if (!string.IsNullOrEmpty(cacheContent))
            {
                return cacheContent;
            }
            var sysconf = _sysconfigrepository.GetSingle(p => p.Code == code);
            if (sysconf == null)
            {
                throw new Exception("数据表没有配置" + code);
            }
            var content = sysconf.SContent;
            string sysname = sysconf.Default1;//所属系统mes/erp
            RedisHelper.Set("sys_config" + code, content + "|" + sysname);
            return content;
        }

        /// <summary>
        /// 获取配置信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjSysConfig GetSysConfigByCode(string code)
        {
            //Repository<dynamic> _billdtrepository = new Repository<dynamic>();
            return _sysconfigrepository.GetSingle(p => p.Code == code);
        }

        /// <summary>
        /// 获取物料信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjBaseMater GetBaseMaterByExpression(Expression<Func<fjBaseMater, bool>> WhereExpression)
        {
            return _materrepository.GetSingle(WhereExpression);
        }

        /// <summary>
        /// 获取配置信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjSysConfig GetSysConfigByExpression(Expression<Func<fjSysConfig, bool>> WhereExpression)
        {
            return _sysconfigrepository.GetSingle(WhereExpression);
        }

        /// <summary>
        /// 获取单据信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjBillDocument GetBillDocumentByExpression(Expression<Func<fjBillDocument, bool>> WhereExpression)
        {
            return _docrepository.GetSingle(WhereExpression);
        }

        /// <summary>
        /// 获取反馈信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public List<fjBillFeedbackPush> GetBillFeedbackList(Expression<Func<fjBillFeedbackPush, bool>> WhereExpression)
        {
            return _billFbackPushrepository.GetList(WhereExpression);
        }

        ///// <summary>
        ///// 获取单据信息
        ///// </summary>
        ///// <param name="code"></param>
        ///// <returns></returns>
        //public fjBillDocument GetBillDocumentList(Expression<Func<fjBillDocument, bool>> WhereExpression)
        //{
        //    return _billdtrepository.Context.Queryable<fjBillDocument, fjSysConfig>((doc, conf) => new object[] {
        //      JoinType.Left, doc.BState == conf.Code
        //    }).Where((doc, conf) => doc.Status == 0)
        //    .Select((bc, bm) => bc).First();
        //}
        /// <summary>
        /// 更新SysConfig表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateSysConfigModelColumns(UpdateModelColumns<fjSysConfig> updateModel)
        {
            return _sysconfigrepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }

        /// <summary>
        /// 更新hjBillFeedbackPush表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateBillFeedbackPushModelColumns(UpdateModelColumns<fjBillFeedbackPush> updateModel)
        {
            return _billFbackPushrepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }

        public SRes<bool> DeleteDoc(Expression<Func<fjBillDocument, bool>> whereExpression)
        {
            var res = new SRes<bool>();
            res.ResData = _docrepository.Delete(whereExpression);
            return res;
        }

        public bool SyncMaterInfo(List<FJSyncMaterInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                if (_materrepository.IsAny(p => p.Code == item.MatCode))
                {
                    _materrepository.UpdateModelColumns(p => new fjBaseMater() { IsHold = item.IsHold, HoldDuration = item.HoldDuration },
                       p => p.Code == item.MatCode);
                }
                else
                {
                    var model = _mapper.Map<fjBaseMater>(item);
                    _materrepository.Insert(model);
                }
            }
            return true;
        }

        public bool SyncMachineInfo(List<SyncMachineInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                if (_basemachinforepository.IsAny(p => p.MachNo == item.MacCode))
                {
                    _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { GrpCode = item.MacGroup, Direction = item.Direction, Station = item.LocCode, EditTime = DateTime.Now },
                       p => p.MachNo == item.MacCode);
                }
                else
                {
                    var model = _mapper.Map<BillMachinfo>(item);
                    _basemachinforepository.Insert(model);
                }
            }
            return true;
        }

        /// <summary>
        /// 帘线工单信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            var res = new SRes();
            var doc = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
            if (doc == null)
            {
                doc = new BillDocsinfo();
                doc.WarehouseId = 0;
                doc.ReqNo = reqDto.BillCode;
                doc.DocsNo = reqDto.BillCode;
                doc.TypeNum = DocType.DocType_FJ_CurtainProduction.GetHashCode();
                doc.StateNum = DocState.DocState_Create.GetHashCode();
                doc.JsonContent = JsonConvert.SerializeObject(reqDto);
                doc.DownQty = 1;
                doc.IsStop = 0;
                var docinsert = _billdocrepository.Insert(doc);
                if (!docinsert)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                    return res;
                }
            }
            _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { BillCode = reqDto.BillCode, WorkOrder = reqDto.WorkOrder, PlanQty = reqDto.PlanQty, EditTime = DateTime.Now }, p => reqDto.WbList.Contains(p.MachNo));
            return res;
        }

        /// <summary>
        /// 工单启动验证
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainOrderStartCheck(CurtainOrderStartCheckRequest reqDto)
        {
            var res = new SRes();
            var wetStack = _billBominfoRepository.GetSingle(p => p.BillCode == reqDto.BillCode);
            if (wetStack == null)
            {
                res.ResCode = 0;
                res.ResMsg = reqDto.BillCode + "没有配置垛型信息,请先配置垛型";
                return res;
            }
            return res;
        }

        #region 湿拉工字轮/帘线芯股信息初始化

        /// <summary>
        ///  湿拉工字轮/帘线芯股信息初始化
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes SpoolMaterialInfoTrans(SpoolMaterialInfoTransRequest reqDto)
        {
            var res = new SRes();
            var container = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.SpoolCode);
            if (container == null)
            {
                var insertcon = new BaseContinfo()
                {
                    ContBarCode = reqDto.SpoolCode,
                    Name = reqDto.SpoolCode,
                    TypeCode = ContainerType.ContainerType_Spool.ToString(),
                    PrintQty = 1,
                    IsStop = 0,
                    WarehouseId = 0,
                    WeightQty = 0,
                    AddWho = "wms",
                    AddTime = DateTime.Now
                };
                //新加载具信息
                if (!_baseContinfo.Insert(insertcon))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = "工字轮载具初始化失败";
                    return res;
                }
            }
            var mater = _basematerrepository.GetSingle(p => p.Code == reqDto.MatCode);
            if (mater == null)
            {
                res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                return res;
            }
            BillSpoolTrans billSpoolTrans = new BillSpoolTrans();
            billSpoolTrans.ConBarCode = reqDto.SpoolCode;
            billSpoolTrans.BillCode = reqDto.BillCode;
            billSpoolTrans.WorkOrder = reqDto.WorkOrder;
            billSpoolTrans.AddTime = DateTime.Now;
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.SpoolCode);
            if (stock != null && stock.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = "该工字轮条码号已在库中，请检查RFID号是否重复";
            }
            if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成";
            }

            //条码验证
            var barstock = _billInvnowrepository.GetSingle(p => p.InvBarCode == reqDto.MatBarCode);
            if (barstock != null && barstock.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = "该材料号已在库中，请检查是否重复";
            }
            if (barstock != null && barstock.ContGrpBarCode != reqDto.SpoolCode)
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = reqDto.MatBarCode + "该材料号已经绑定" + barstock.ContGrpBarCode + "，请检查是否重复";
            }
            var barinfo = _billInvinitrepository.GetSingle(p => p.InvBarCode == reqDto.MatBarCode);
            if (barinfo == null)
            {
                barinfo = new BillInvinit()
                {
                    InvBarCode = reqDto.MatBarCode,
                    WarehouseId = 0,
                    ContGrpId = IdFactory.NewId(),
                    ContGrpBarCode = reqDto.SpoolCode,
                    ExecStateCode = InvLockState.InvState_Normal.ToString(),
                    ExecDocsNo = reqDto.WorkOrder,
                    ExecDocsRowNo = reqDto.MatBarCode,
                    ExecDocsTypeCode = DocType.DocType_HJ_CopperProductStockIn.GetHashCode().ToString(),
                    InvInOut = InvInOutType.In.GetHashCode(),
                    ExecWho = "MES",
                    EditTime = DateTime.Now,
                    InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                    InDocsNo = reqDto.BillCode,
                    InDocsRowNo = reqDto.MatBarCode,
                    SuppCode = "",
                    MatId = mater.Id,
                    MatCode = mater.Code,
                    MatName = mater.Name,
                    LengthQty = reqDto.Length,
                    TareWQty = reqDto.Weight,
                    ProductTime = reqDto.ProductDate,
                    RFIDBarCode = "",
                    ProductLineNo = "",
                    Grade = reqDto.Grade,
                    HWBarCode = "",
                    HWTypeCode = reqDto.SpoolType,//工字轮类型
                    IsFast = reqDto.IsFast,
                    IsRework = false,
                    CLBarCode = reqDto.MatBarCode,
                    Size = 1,
                    AddTime = DateTime.Now,
                    BackReason = "",
                    IsBack = reqDto.IsBack,
                    SilkTypeCode = reqDto.SilkType,
                    IsCore = reqDto.BusType == "2",
                };
                _billInvinitrepository.InsertReturnEntity(barinfo);
                _billSpoolTransrepository.InsertReturnEntity(billSpoolTrans);
            }
            return res;
        }

        #endregion 湿拉工字轮/帘线芯股信息初始化

        /// <summary>
        /// 分配分拣库
        /// </summary>
        /// <returns></returns>
        public bool AllocationWarehouseSort(AllocationWarehouseSortRequest reqDto)
        {
            return true;
        }

        /// <summary>
        /// 二次扫码分配输送地址
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes AllocationConveyorSort(AllocationConveyorSortRequest reqDto)
        {
            var res = new SRes();
            var baritem = _billSpoolTransrepository.GetFirst(p => p.ConBarCode == reqDto.BarCode);
            //判断当前库是否有mix垛型
            var mixrow = _billBomsetinfoRepository.AsQueryable().Where(p => p.IsMixRow == 1 && p.WarehouseCode == baritem.WarehouseCode);
            if (mixrow == null || !mixrow.Any())
            {
                var matcodelist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseCode == baritem.WarehouseCode);
                var curmatrate = matcodelist.Where(p => p.MatCode == baritem.MatCode).Count() / matcodelist.Count();
                //需要的总量
            }
            else
            {
            }
            var translist = _billSpoolTransrepository.AsQueryable().Where(p => p.WarehouseCode == baritem.WarehouseCode).ToList();
            foreach (var item in translist.GroupBy(p => p.ConveyorSort))
            {
            }
            return res;
        }

        /// <summary>
        /// 帘线领料出库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionStockOut(CurtainProductionStockOutRequest reqDto)
        {
            var res = new SRes();

            var warehosue = _baseWareHouserepository.GetSingle(p => p.Code == reqDto.WareCode);
            if (warehosue == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var doc = _docrepository.GetSingle(p => p.DocNo == reqDto.BillCode);
            if (doc == null)
            {
                doc = new fjBillDocument();
                doc.WarehouseId = warehosue.Id;
                //保存单据信息
                doc.ReqNo = reqDto.ReqId;
                doc.DocNo = reqDto.BillCode;
                doc.TypeCode = DocType.DocType_FJ_CurtainProductionStockOut.ToString();
                doc.StateCode = DocState.DocState_Create.ToString();
                doc.ContentJson = JsonConvert.SerializeObject(reqDto);
                doc.DownQty = 1;
                var docinsert = _docrepository.Insert(doc);
                if (!docinsert)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                    return res;
                }
            }
            return res;
        }

        public SRes ProductionBack(FjProductionBackRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes ProductionLeftFeedBack(string doccode)
        {
            var res = new SRes();
            return res;
        }

        public SRes ErrorMaterialStockOut(FjErrorMaterialStockOutRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes BGradeMaterialStockOut(BGradeMaterialStockOutRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes StockChange(FjStockChangeRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        #region 空托盘入库

        /// <summary>
        ///  一楼空托盘人工入库任务创建
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes OneFloorWorkerBuildEmptyPalletsStock(FJBuildEmptyPalletsStockRequest reqDto)
        {
            var res = new SRes();

            var req = _mapper.Map<FJBuildEmptyPalletsStockDto>(reqDto);
            req.Floor = 1;
            req.BusType = FJTaskBusType.OneLayerManualPallets;

            //TODO:条码长度待定
            //if (reqDto.PalletCode.Length != 12)
            //{
            //    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            //    res.ResMsg = "MES上传的RFID长度不等于12位";
            //    return res;
            //}
            res = FJEmptyPalletsStockIn(req);

            return res;
        }

        /// <summary>
        /// 分拣库空托盘入库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes FJEmptyPalletsStockIn(FJBuildEmptyPalletsStockDto reqDto)
        {
            var res = new CopperLineResponse();
            FJTaskBusType BusType = reqDto.BusType;

            //验证业务类型
            if (reqDto.BusType <= FJTaskBusType.def || reqDto.BusType > FJTaskBusType.OneLayerAutoPallets)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = "指令类型" + reqDto.BusType + ResponseStatusCodeEnum.ErrParam.GetDescription();
                return res;
            }

            //验证是否有空余货位
            res = _mapper.Map<CopperLineResponse>(IsThereAnySpaceVacancy());
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //检查仓库是否存在
            res = _mapper.Map<CopperLineResponse>(CheckWareCode(reqDto.WareCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证容器是否存在
            res = _mapper.Map<CopperLineResponse>(CheckContinfo(reqDto.PalletCode, FJContainerType.ContainerType_Pallet));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证托盘是否有未结束的任务
            res = _mapper.Map<CopperLineResponse>(CheckNoFinishTask(reqDto.PalletCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证是否存在库存信息
            res = _mapper.Map<CopperLineResponse>(CheckInvnow(reqDto.PalletCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //保存条码信息 空托盘条码即条码表条码
            var barinfo = _billInvinitrepository.GetSingle(p => p.InvBarCode == reqDto.PalletCode);
            if (barinfo == null)
            {
                var warehosue = _basewarehouserepository.GetSingle(p => p.Code == reqDto.WareCode);
                barinfo = new BillInvinit()
                {
                    InvBarCode = reqDto.PalletCode,
                    WarehouseId = warehosue.Id,
                    ContGrpId = IdFactory.NewId(),
                    ContGrpBarCode = reqDto.PalletCode,
                    ExecStateCode = FJInvLockState.InvState_Normal.ToString(),
                    ExecDocsTypeCode = FJDocType.DocType_FJ_EmptyPalletsStockIn.GetHashCode().ToString(),
                    InvInOut = FJInvInOutType.In.GetHashCode(),
                    ExecWho = "WCS",
                    EditTime = DateTime.Now,
                    InvStateCode = FJInvState.InvEcecState_BuildUp.ToString(),
                    SuppCode = "",
                    Size = 1,
                    MatCode = reqDto.PalletCode,
                    AddTime = DateTime.Now,
                };

                barinfo = _billInvinitrepository.InsertReturnEntity(barinfo);
            }

            //生成库存信息-分解方法
            var createStockRes = CreateStock(new List<BillInvinit>() { barinfo }, reqDto.PalletCode, FJContainerType.ContainerType_Pallet);
            if (createStockRes.ResCode != 200)
            {
                res.ResCode = createStockRes.ResCode;
                res.ResMsg = createStockRes.ResMsg;
                return res;
            }

            var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest()
            {
                BusType = BusType.GetDescription(),
                ContGrpBarCode = reqDto.PalletCode,
                ContGrpId = createStockRes.ResDataList.First().ContGrpId,
                Qty = reqDto.PalletNum.ObjToDecimal(),
                EquCode = reqDto.StartLoc,
                WarehouseCode = reqDto.WareCode,
                Floor = reqDto.Floor,
            };

            //下发wcs任务 - 分解方法
            var taskres = CreateStockInWcsTask(createStockInWcsTaskReqest);
            if (taskres.ResCode != 200)
            {
                res.ResCode = taskres.ResCode;
                res.ResMsg = taskres.ResMsg;
                return res;
            }
            //生成流水数据-分解方法
            CreateInvFlow(createStockRes.ResDataList);

            return res;
        }

        #endregion 空托盘入库

        #region 满轮同WCS交互

        #region 主线

        #region 分库

        /// <summary>
        ///  工字轮/芯股进入主线扫码
        /// </summary>
        /// <returns></returns>
        public SRes<SRes> EnteMainLine(FJEnteMainLineRequest reqDto)
        {
            var res = new SRes<SRes>();

            try
            {
                //RedisHelper.LPush(nameof(EnteMainLine), reqDto.IShapedWheelCodes);
                foreach (var item in reqDto.IShapedWheelCodes)
                {
                    var res1 = AllocationWarehouseSort(item);
                    res.ResDataList.Add(res);
                }
                res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription();
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
            }
            return res;
        }

        /// <summary>
        /// 分配分拣库
        /// </summary>
        /// <param name="code">工字轮条码</param>
        /// <returns></returns>
        public SRes AllocationWarehouseSort(string code)
        {
            //开始分配分拣库
            var res = new SRes();
            //找到码垛工字轮信息
            var spoolTrans = _billSpoolTransrepository.GetSingle(p => p.ConBarCode == code);
            if (spoolTrans == null)
            {
                //创建容器信息
                var cont = new BillSpoolTrans
                {
                    ConBarCode = code,
                    WarehouseCode = null,
                    AddWho = "WMS",
                    AddTime = DateTime.Now,
                    WorkOrder = "20230210"
                };
                //加载新的容器信息
                if (!_billSpoolTransrepository.Insert(cont))
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "RFID载具初始化失败";
                    return res;
                }
                spoolTrans = _billSpoolTransrepository.GetSingle(p => p.ConBarCode == code);
            }
            if (!spoolTrans.WarehouseCode.IsNullOrEmpty())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "已完成分库";
                return res;
            }

            //验证容器是否存在
            res = _mapper.Map<CopperLineResponse>(CheckContinfo(code, FJContainerType.ContainerType_IShapedWheel));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证工字轮是否有未结束的任务
            res = _mapper.Map<CopperLineResponse>(CheckNoFinishTask(code));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证是否存在库存信息
            res = _mapper.Map<CopperLineResponse>(CheckInvnow(code));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //通过订单找到对应的机台信息
            var maclist = _basemachinforepository.AsQueryable().Where(p => p.WorkOrder == spoolTrans.WorkOrder);
            var warelist = maclist.Select(p => p.WarehouseCode).Distinct().OrderBy(v => v); //找到机台对应的仓库信息
            if (!warelist.Any()) //当前订单没有对应仓库信息
            {
                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans()
                {
                    ErrType = 1,
                    ErrMsg = "没有配置机台信息",
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == spoolTrans.ConBarCode);
            }
            else if (warelist.Count() == 1) //当前订单对应一个仓库信息
            {
                int sort = int.Parse(warelist.First().Substring(0, 1));
                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans()
                {
                    WarehouseCode = warelist.First(),
                    WarehouseSort = sort,
                    Direct = warelist.First().Substring(1, 1),
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == spoolTrans.ConBarCode);
                spoolTrans.WarehouseCode = warelist.First();
                spoolTrans.WarehouseSort = sort;
                spoolTrans.Direct = warelist.First().Substring(1, 1);
            }
            else //当前订单对应多个仓库信息
            {
                //TODO:怎么计算当前订单在当前仓库需要码多少托，跟据当前仓库已有订单需要的托盘数量计算各订单在可用码垛工位占比，再计算当前托盘该码什么跺

                var waretemplist = maclist.Select(p => new { p.WarehouseCode, p.WorkOrder, p.BillCode, p.PlanQty }).Distinct();
                var warehouselist = _basewarehouserepository.GetList().Select(p => p.Id);
                foreach (var warehouse in warehouselist)
                {
                    var stackdetaillist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseId == warehouse);
                    getMatProport(spoolTrans.MatCode, warehouse);
                }
            }

            //保存条码信息 空托盘条码即条码表条码
            //TODO:此处条码号应当使用材料号，测试时使用条码
            var barinfo = _billInvinitrepository.GetSingle(p => p.InvBarCode == code);
            if (barinfo == null)
            {
                var warehosue = _basewarehouserepository.GetSingle(p => p.Code == spoolTrans.WarehouseCode);
                barinfo = new BillInvinit()
                {
                    InvBarCode = code,
                    WarehouseId = warehosue.Id,
                    ContGrpId = IdFactory.NewId(),
                    ContGrpBarCode = code,
                    ExecStateCode = FJInvLockState.InvState_Normal.ToString(),
                    ExecDocsTypeCode = FJDocType.DocType_FJ_EmptyPalletsStockIn.GetHashCode().ToString(),
                    InvInOut = FJInvInOutType.In.GetHashCode(),
                    ExecWho = "WCS",
                    EditTime = DateTime.Now,
                    InvStateCode = FJInvState.InvEcecState_BuildUp.ToString(),
                    SuppCode = "",
                    Size = 1,
                    MatCode = spoolTrans.MatCode,
                    AddTime = DateTime.Now,
                };

                barinfo = _billInvinitrepository.InsertReturnEntity(barinfo);
            }

            //生成库存信息-分解方法
            var createStockRes = CreateStock(new List<BillInvinit>() { barinfo }, code, FJContainerType.ContainerType_Pallet);
            if (createStockRes.ResCode != 200)
            {
                res.ResCode = createStockRes.ResCode;
                res.ResMsg = createStockRes.ResMsg;
                return res;
            }

            //开始生成WCS

            var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest()
            {
                BusType = FJTaskBusType.二楼组盘.GetDescription(),
                ContGrpBarCode = code,
                ContGrpId = createStockRes.ResDataList.First().ContGrpId,
                Qty = 1,
                WarehouseCode = spoolTrans.WarehouseCode,
                Floor = 2,
            };

            //下发wcs任务 - 分解方法
            var taskres = CreateStockInWcsTask(createStockInWcsTaskReqest);
            if (taskres.ResCode != 200)
            {
                res.ResCode = taskres.ResCode;
                res.ResMsg = taskres.ResMsg;
                return res;
            }
            //生成流水数据-分解方法
            CreateInvFlow(createStockRes.ResDataList);
            RedisHelper.Set($"AllocationWarehouseSort:{code}", JsonConvert.SerializeObject(new MainlineDiversion()
            {
                TaskId = taskres.ResData.ID,
                WarehouseCode = spoolTrans.WarehouseCode
            }));
            return res;
        }

        /// <summary>
        ///  计算物料在该仓库的比例
        /// </summary>
        /// <param name="matcode">物料编号</param>
        /// <param name="warehousecode">仓库编号</param>
        /// <returns></returns>
        public decimal getMatProport(string matcode, long warehouseId)
        {
            //计算此仓库所有该物料的量 已组盘/已入库
            var stackLisk = _billInvnowrepository.AsQueryable()
                                                 .Count(v => v.WarehouseId == warehouseId
                                                          && v.MatCode == matcode
                                                          && (v.ExecStateCode == FJInvState.InvEcecState_BuildUp.ToString() || v.ExecStateCode == FJInvState.InvEcecState_In.ToString()));

            //每的单子（每盘的数量）
            var stackdetaillist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseId == warehouseId);
            return 0;
        }

        #endregion 分库

        #endregion 主线

        #endregion 满轮同WCS交互

        public SRes BomInfoTrans(BomInfoTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes FJ1NorthAutoGenerateLocation()
        {
            SRes res = new SRes();
            BaseWarehouse BaseWarearea = new BaseWarehouse()
            {
                Id = IdFactory.NewId(),
                IsStop = 0,
                Code = "1N",
                Name = "分拣库1北",
                AddTime = DateTime.Now
,
                AddWho = "admin",
                EditTime = DateTime.Now,
                EditWho = "admin",
                TypeNum = 1
            };
            var baseWareareaEntity = _basewarehouserepository.InsertReturnEntity(BaseWarearea);
            var dbBaseWarecellLists = _basewarehouserepository.AsQueryable().ToList();
            var shelfcode = "";
            var list = new List<BaseWarecell>();
            var codes = new List<string>();
            for (int row = 1; row <= 2; row++) //行
            {
                int tunnel = 1;

                //12行 48列9层
                for (int layer = 1; layer <= 10; layer++) //层
                {
                    for (int col = 1; col <= 10; col++) //列
                    {
                        var code = row.ToString().PadLeft(2, '0') + "-" + col.ToString().PadLeft(2, '0') + "-" + layer.ToString().PadLeft(2, '0') + "-" + tunnel;
                        codes.Add(code);
                        var name = row.ToString() + "行" + col.ToString() + "列" + layer.ToString() + "层";
                        list.Add(new BaseWarecell
                        {
                            Id = IdFactory.NewId(),
                            WarehouseId = baseWareareaEntity.Id,
                            WareAreaId = 1669154208777113600,
                            IsStop = 0,
                            Code = code,
                            Name = name,
                            StateNum = 1,
                            TypeNum = 1,
                            Size = 1,
                            Shelf = tunnel.ToString() + shelfcode,
                            WarehouseCode = BaseWarearea.Code,
                            Row = row,
                            Col = col,
                            Layer = layer,
                            Depth = 1,
                            Tunnel = tunnel,
                            SCRel = "SRM" + tunnel.ToString().PadLeft(2, '0'),
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            Memo = "",
                            AddWho = "admin",
                            AddTime = DateTime.Now,
                            EditWho = "admin",
                            EditTime = DateTime.Now,
                        });
                    }
                }
            }

            _basewarecellrepository.InsertRange(list);
            return res;
        }

        public SRes FJSouthAutoGenerateLocation()
        {
            SRes res = new SRes();

            BaseWarehouse BaseWarearea = new BaseWarehouse()
            {
                Id = IdFactory.NewId(),
                IsStop = 0,
                Code = "1S",
                Name = "分拣库1南",
                AddTime = DateTime.Now,
                AddWho = "admin",
                EditTime = DateTime.Now,
                EditWho = "admin",
                TypeNum = 1
            };

            var baseWareareaEntity = _basewarehouserepository.InsertReturnEntity(BaseWarearea);

            var dbBaseWarecellLists = _basewarehouserepository.AsQueryable().ToList();
            var shelfcode = "";
            var list = new List<BaseWarecell>();
            var codes = new List<string>();
            for (int row = 1; row <= 2; row++) //行
            {
                int tunnel = 1;

                //12行 48列9层
                for (int layer = 1; layer <= 10; layer++) //层
                {
                    for (int col = 11; col <= 20; col++) //列
                    {
                        var code = row.ToString().PadLeft(2, '0') + "-" + col.ToString().PadLeft(2, '0') + "-" + layer.ToString().PadLeft(2, '0') + "-" + tunnel;
                        codes.Add(code);
                        var name = row.ToString() + "行" + col.ToString() + "列" + layer.ToString() + "层";
                        list.Add(new BaseWarecell
                        {
                            Id = IdFactory.NewId(),
                            WarehouseId = baseWareareaEntity.Id,
                            WareAreaId = 1669154208777113600,
                            IsStop = 0,
                            Code = code,
                            Name = name,
                            StateNum = 1,
                            TypeNum = 1,
                            Size = 1,
                            Shelf = tunnel.ToString() + shelfcode,
                            WarehouseCode = BaseWarearea.Code,
                            Row = row,
                            Col = col,
                            Layer = layer,
                            Depth = 1,
                            Tunnel = tunnel,
                            SCRel = "SRM" + 2,
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            Memo = "",
                            AddWho = "admin",
                            AddTime = DateTime.Now,
                            EditWho = "admin",
                            EditTime = DateTime.Now,
                        });
                    }
                }
            }

            _basewarecellrepository.InsertRange(list);
            return res;
        }

        #region 巷道及货位分配

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> ApplyStockInLoc(FJApplyStockInLocRequest reqEntity)
        {
            var res = ApplyStockInLocTemp(reqEntity);
            if (string.IsNullOrEmpty(res.ResData.CellNo))
            {
                return res;
            }

            try
            {
                var task = _taskrepository.GetFirst(p => p.ID == reqEntity.TaskNum);
                var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                _db.BeginTran();

                //更新货位
                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_StockIn.GetHashCode(), ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                       p => p.Code == res.ResData.CellNo);
                //更新任务
                //_wcstaskoldrepository.UpdateModelColumns(p => new WCS_TaskOld() { AddrTo = res.ResData.CellNo,  EditTime = DateTime.Now },
                //       p => p.ID == reqEntity.TaskNum);
                //_taskrepository.UpdateModelColumns(p => new WCS_TaskInfo() { AddrTo = res.ResData.CellNo,  EditTime = DateTime.Now },
                //       p => p.ID == reqEntity.TaskNum);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
            }
            return res;
        }

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> ApplyStockInLocTemp(FJApplyStockInLocRequest reqEntity)
        {
            var result = new SRes<FJApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new FJApplyStockInLocResponse()
            };
            //检擦任务是否异常
            var wcstask = _wcstaskoldrepository.AsQueryable().SplitTable(tabs => tabs.Take(3)).Where(p => p.ID == reqEntity.TaskNum).First(); ;
            if (wcstask == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            if (wcstask.Type == TaskType.OutDepot)
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                result.ResMsg = "该任务是出库任务，不能分配货位；wms任务号" + wcstask.ID;
                return result;
            }
            if (!string.IsNullOrEmpty(wcstask.AddrTo) && wcstask.AddrTo != "SRM")//如果目标地址不是堆垛机
            {
                result.ResData.TunnelNum = wcstask.Tunnel;
                result.ResData.CellNo = wcstask.AddrTo;
                result.ResData.Row = wcstask.AddrTo.Split('-')[0] != null ? int.Parse(wcstask.AddrTo.Split('-')[0]) : 0;
                result.ResData.Colomn = wcstask.AddrTo.Split('-')[1] != null ? int.Parse(wcstask.AddrTo.Split('-')[1]) : 0;
                result.ResData.Layer = wcstask.AddrTo.Split('-')[2] != null ? int.Parse(wcstask.AddrTo.Split('-')[2]) : 0;
                return result;
            }
            if (reqEntity.TunnelNum <= 0)
            {
                result.ResCode = ResponseStatusCodeEnum.NotTunnelNum.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.NotTunnelNum.GetDescription();
                return result;
            }
            //验证仓库信息
            var warehouse = _basewarehouserepository.GetFirst(p => p.Code == wcstask.WarehouseCode);
            if (warehouse == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return result;
            }
            //验证库存
            var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
            if (stock == null)
            {
                result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return result;
            }
            if (reqEntity.TunnelNum <= 0)
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                result.ResMsg = "没有传巷道值";
                return result;
            }

            return ApplyLoc(new FJApplyLocRequest()
            {
                MaterialId = stock.MatId,
                MaterialCode = stock.MatCode,
                Size = reqEntity.Height,
                TunnelNum = reqEntity.TunnelNum,
                WarehuoseId = warehouse.Id,
                IsMove = wcstask.Type == TaskType.TransferDepot
            });
        }

        /// <summary>
        ///  分配货位
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> ApplyLoc(FJApplyLocRequest reqEntity)
        {
            var result = new SRes<FJApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new FJApplyStockInLocResponse()
            };

            //预留货位数量
            var emptyLoc = _basewarecellrepository.GetList(p => p.IsStop == 0
            && p.StateNum == LocationState.LocationState_Empty.GetHashCode()
            && p.TypeNum == LocationType.LocationType_StorageLocation.GetHashCode()
            && p.Tunnel == reqEntity.TunnelNum
            && p.WarehouseId == reqEntity.WarehuoseId
            && p.Size == reqEntity.Size
            );

            //判断是否移库
            if (!reqEntity.IsMove && (emptyLoc == null || emptyLoc.Count < 2))
            {
                result.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return result;
            }

            //找到可用货位
            var loc1ist = _basewarecellrepository.Context
                         .Queryable<BaseWarecell>()
                         .Where((loc1) => loc1.IsStop == 0
                                            && loc1.StateNum == LocationState.LocationState_Empty.GetHashCode()
                                            && loc1.TypeNum == LocationType.LocationType_StorageLocation.GetHashCode()
                                            && loc1.Tunnel == reqEntity.TunnelNum
                                            && loc1.WarehouseId == reqEntity.WarehuoseId
                                            && loc1.Size == reqEntity.Size
                                            && loc1.Depth == 1)
                         .Where((loc1) => loc1.Tunnel == reqEntity.TunnelNum)
                         .Select((loc1) => new
                         {
                             loc1.Code,
                             loc1.Id,
                             loc1.Row,
                             loc1.Col,
                             loc1.Layer,
                             loc1.Tunnel,
                         });

            if (loc1ist != null)
            {
                var resloc = loc1ist.ToList().OrderBy(p => p.Layer).ThenBy(p => p.Col).ThenBy(p => p.Row).First();
                result.ResData.TunnelNum = resloc.Tunnel.ToString();
                result.ResData.CellNo = resloc.Code;
                result.ResData.Row = resloc.Row;
                result.ResData.Colomn = resloc.Col;
                result.ResData.Layer = resloc.Layer;
                return result;
            }

            if (loc1ist == null || !loc1ist.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return result;
            }

            var loc = loc1ist.First();
            result.ResData.TunnelNum = loc.Tunnel.ToString();
            result.ResData.CellNo = loc.Code;
            result.ResData.Row = loc.Row;
            result.ResData.Colomn = loc.Col;
            result.ResData.Layer = loc.Layer;
            return result;
        }

        #endregion 巷道及货位分配

        #region 容器、物料、条码、库存检测及创建，创建流水信息

        /// <summary>
        ///  检查容器是否存在，不存在则创建
        /// </summary>
        /// <param name="contBarCode">容器条码</param>
        /// <param name="fjContainerType">容器类型</param>
        /// <returns></returns>
        public SRes CheckContinfo(string contBarCode, FJContainerType fjContainerType)
        {
            SRes res = new SRes();
            var container = _baseContinfo.GetSingle(x => x.ContBarCode == contBarCode);
            if (container == null)
            {
                //创建容器信息
                var cont = new BaseContinfo
                {
                    ContBarCode = contBarCode,
                    Name = contBarCode,
                    TypeCode = fjContainerType.ToString(),
                    PrintQty = 1,
                    IsStop = 0,
                    WarehouseId = 0,
                    AddWho = "WMS",
                    AddTime = DateTime.Now
                };
                //加载新的容器信息
                if (!_baseContinfo.Insert(cont))
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "RFID载具初始化失败";
                    return res;
                }
            }
            else if (container.IsStop != 0)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "容器已停用";
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  跟据库存信息创建流水信息
        /// </summary>
        /// <param name="barlist">库存信息</param>
        /// <returns></returns>
        public SRes CreateInvFlow(List<BillInvnow> barlist)
        {
            var res = new SRes();
            var listflow = _mapper.Map<List<BillInvflow>>(barlist);
            foreach (var item in listflow)
            {
                item.AddTime = DateTime.Now;
                item.Id = IdFactory.NewId();
            }
            _billInvflow.InsertRange(listflow);
            return res;
        }

        /// <summary>
        ///  跟据库存信息创建流水信息
        /// </summary>
        /// <param name="bar">库存信息</param>
        /// <returns></returns>
        public SRes CreateInvFlow(BillInvnow bar)
        {
            var res = new SRes();
            var flow = _mapper.Map<BillInvflow>(bar);
            flow.AddTime = DateTime.Now;
            flow.Id = IdFactory.NewId();
            _billInvflow.Insert(flow);
            return res;
        }

        /// <summary>
        ///  是否有空余货位
        /// </summary>
        /// <returns></returns>
        public SRes IsThereAnySpaceVacancy()
        {
            var res = new SRes();
            //验证有剩余货位
            if (_basewarecellrepository.GetList(p => p.IsStop == 0 && p.StateNum == FJLocationState.LocationState_Empty.GetHashCode()).Count() < 2)
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        /// 检查传入的仓库是否存在
        /// </summary>
        /// <param name="wareCode">仓库编号</param>
        /// <returns></returns>
        public SRes CheckWareCode(string wareCode)
        {
            var res = new SRes();
            //验证是否有对应仓库
            var warehosue = _basewarehouserepository.GetSingle(p => p.Code == wareCode);
            if (warehosue == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  验证空托盘是否有未结束的任务
        /// </summary>
        /// <param name="PalletCode"></param>
        /// <returns></returns>
        public SRes CheckNoFinishTask(string PalletCode)
        {
            SRes res = new SRes();
            //验证当前托盘是否有未结束的任务
            var task = _wcstaskoldrepository.AsQueryable().Where(p => p.BarCode == PalletCode && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task != null && task.ID > 0)
            {
                switch (task.Type)
                {
                    case TaskType.SetPlate:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号组盘任务还未完成，请先完成组盘任务";
                        return res;

                    case TaskType.EnterDepot:
                        if (task.Status > TaskStatus.WaitingToExecute && task.Status < TaskStatus.Finish)
                        {
                            res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                            res.ResMsg = PalletCode + "已有进行中任务，请检查托盘条码是否重复";
                            return res;
                        }
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "任务已创建，请勿重复申请";
                        return res;

                    case TaskType.OutDepot:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号出库任务还未完成，请先完成出库任务";
                        return res;

                    case TaskType.TransferDepot:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号移库任务还未完成，请先完成移库任务";
                        return res;

                    case TaskType.Delivery:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号输送任务还未完成，请先完成输送任务";
                        return res;

                    case TaskType.EmptyInit:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号空轮初始化任务还未完成，请先完成空轮初始化任务";
                        return res;
                }
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  检查是否存在库存信息
        /// </summary>
        /// <param name="code">编码</param>
        /// <returns></returns>
        public SRes CheckInvnow(string code)
        {
            SRes res = new SRes();

            //验证是否没有库存信息
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code);
            if (stock != null && stock.InvStateCode == FJInvState.InvEcecState_In.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = code + "该托盘号已在库中，请检查托盘号是否重复";
                return res;
            }
            else if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = code + "该托盘号存在出库中任务，请检查上一个任务是否已经完成";
                return res;
            }
            else if (stock != null)
            {
                res.ResCode = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetDescription();
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  创建库存信息
        ///  不验证容器是否存在
        ///  不验证容器是否有未结束的任务
        ///  不验条码信息是否存在
        /// </summary>
        /// <param name="barList">条码集合</param>
        /// <param name="containerBarcode">容器编号</param>
        /// <param name="containerType">容器类型</param>
        /// <returns></returns>
        public SRes<BillInvnow> CreateStock(List<BillInvinit> barList, string containerBarcode, FJContainerType containerType)
        {
            var res = new SRes<BillInvnow>();
            if (string.IsNullOrEmpty(containerBarcode))
            {
                res.ResCode = ResponseStatusCodeEnum.ContainerCodeNotEmpty.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ContainerCodeNotEmpty.GetDescription();
                return res;
            }

            //将条码表映射到库存表
            var stocklist = _mapper.Map<List<BillInvnow>>(barList);
            foreach (var item in stocklist)
            {
                item.AddTime = DateTime.Now;
                item.Id = IdFactory.NewId();
            }

            if (!_billInvnowrepository.InsertRange(stocklist))
            {
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = "托盘库存信息存储失败";
                return res;
            }

            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResDataList = stocklist;
            return res;
        }

        /// <summary>
        ///  创建WCS任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<WCS_TaskInfo> CreateStockInWcsTask(FJCreateStockInWcsTaskRequest reqDto)
        {
            var res = new SRes<WCS_TaskInfo>();
            var wcstask = new WCS_TaskInfo()
            {
                Type = TaskType.EnterDepot,
                Status = TaskStatus.NewBuild,
                Priority = 0,
                Device = "",
                SrmStation = "",
                AddrFrom = reqDto.EquCode,
                AddrTo = "SRM",
                LastInteractionPoint = "",
                BarCode = reqDto.ContGrpBarCode,
                Floor = reqDto.Floor,
                Length = reqDto.Qty,
                AddTime = DateTime.Now,
                StartTime = DateTime.Now,
                DocID = 0,
                PalletType = 1,
                ProdLine = 0,
                AddWho = "WMS",
                WarehouseCode = reqDto.WarehouseCode,
                Enabled = true,
                //WorkBench = reqDto.EquCode,
                //MaterialCode = reqDto.MaterialCode,
                //MatCode = reqDto.MatCode,
                BusType = reqDto.BusType
            };
            var wcstaskhis = _mapper.Map<WCS_TaskOld>(wcstask);

            try
            {
                _db.BeginTran();
                var task = _taskrepository.InsertReturnEntity(wcstask);
                wcstaskhis.ID = task.ID;
                _wcstaskoldrepository.InsertableSplitTable(wcstaskhis);
                var taskdetail = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.EquCode,
                    AddTime = DateTime.Now,
                    AddWho = "WMS",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = reqDto.EquCode + "分拣库一楼空托盘入库",
                };
                _taskdetailrepository.InsertableSplitTable(taskdetail);
                _db.CommitTran();
                res.ResData = task;
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                _logger.LogInformation("保存任务异常：" + ex.ToString());
                return res;
            }
            return res;
        }

        #endregion 容器、物料、条码、库存检测及创建，创建流水信息

        /// <summary>
        ///  手动出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public string ManualTask(FJManualTaskRequest request)
        {
            var res = new SRes();

            //必须要有货位信息
            if (!request.Location.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = "货位" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res.ToCamelCaseString();
            }
            try
            {
                foreach (var item in request.Location)
                {
                    //货位信息验证
                    var location = _basewarecellrepository.GetSingle(p => p.Code == item);
                    if (location == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                        return res.ToCamelCaseString();
                    }
                    if (location.StateNum != FJLocationState.LocationState_Full.GetHashCode())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.Fail.GetDescription() + "货位状态不满足出库条件";
                        return res.ToCamelCaseString();
                    }
                    if (location.IsStop == 1)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + item + "被禁用";
                        return res.ToCamelCaseString();
                    }

                    //库存信息验证
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == location.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res.ToCamelCaseString();
                    }
                    if (stock.InvStateCode != InvState.InvEcecState_In.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = item + "组盘状态不是已入库";
                        return res.ToCamelCaseString();
                    }

                    WCS_TaskInfo billTask = new WCS_TaskInfo();
                    billTask.Status = TaskStatus.NewBuild;
                    billTask.Type = TaskType.OutDepot;
                    billTask.Priority = 0;
                    billTask.Device = "SRM" + location.Tunnel;
                    billTask.AddrFrom = item;
                    billTask.AddrTo = request.AddTo;
                    billTask.BarCode = stock.ContGrpBarCode;
                    billTask.StartTime = DateTime.Now;
                    billTask.AddTime = DateTime.Now;
                    billTask.EditTime = DateTime.Now;
                    billTask.AddWho = "WMS";
                    billTask.WarehouseCode = location.WarehouseCode;
                    billTask.Enabled = true;
                    billTask.Floor = 2;
                    billTask.Tunnel = location.Tunnel.ToString();
                    billTask.PalletType = 1;
                    billTask.Length = stock.LengthQty;
                    billTask.MaterialCode = stock.MatCode;
                    billTask.OutType = OutTypeEnum.半自动手动出库任务;
                    billTask.BusType = FJTaskBusType.TaskBusType_FJ_ManualOut.GetDescription();

                    _db.BeginTran();

                    var wcs = _taskrepository.InsertReturnEntity(billTask);
                    var wcshistory = _mapper.Map<WCS_TaskOld>(wcs);
                    _wcstaskoldrepository.InsertableSplitTable(wcshistory);
                    var taskdetail = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = item,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcs.ID,
                        Desc = wcs.OutType.ToString(),
                    };
                    _taskdetailrepository.InsertableSplitTable(taskdetail);
                    _db.CommitTran();

                    _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                    {
                        StateNum = LocationState.LocationState_StockOut.GetHashCode(),
                        EditTime = DateTime.Now
                    }, p => p.Code == item);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == stock.ContGrpBarCode);

                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = IdFactory.NewId();
                    flow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    flow.EditTime = DateTime.Now;
                    _billInvflow.Insert(flow);
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation("手动出库异常：" + ex.Message);
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                return res.ToCamelCaseString();
            }
            return res.ToCamelCaseString();
        }

        #region 完成/取消任务

        /// <summary>
        ///  完成任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<int> CompleteTask(CompleteTaskRequest reqDto)
        {
            var result = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = reqDto.TaskNum
            };

            //检查历史任务表是否有任务
            var task = _wcstaskoldrepository.AsQueryable().SplitTable(tabs => tabs.Take(3)).Where(p => p.ID == reqDto.TaskNum).First();
            if (task == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }

            switch (task.Type)
            {
                case TaskType.SetPlate:
                    break;

                case TaskType.EnterDepot:

                    try
                    {
                        //检擦库存信息是否正确
                        var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                        if (stock == null)
                        {
                            result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                            result.ResMsg = task.BarCode + "没有已组盘的信息";
                            return result;
                        }

                        var warehouse = _basewarehouserepository.GetSingle(p => p.Code == task.WarehouseCode);
                        _db.BeginTran();
                        int row = int.Parse(task.AddrTo.Split('-')[0]);
                        int col = int.Parse(task.AddrTo.Split('-')[1]);
                        int layer = int.Parse(task.AddrTo.Split('-')[2]);

                        //更新库存
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                        {
                            InvStateCode = InvState.InvEcecState_In.ToString(),
                            PutRow = row,
                            PutCol = col,
                            PutLayer = layer,
                            OneInTime = DateTime.Now,
                            EditTime = DateTime.Now
                        }, p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());

                        //更新货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = LocationState.LocationState_Full.GetHashCode(),
                            ContGrpBarCode = stock.ContGrpBarCode,
                            ContGrpId = stock.ContGrpId,
                            EditTime = DateTime.Now
                        }, p => p.Code.Contains(task.AddrTo));

                        //增加流水信息
                        var enterDepotstocklist = _billInvnowrepository.GetList(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        foreach (var item in enterDepotstocklist)
                        {
                            item.Id = IdFactory.NewId();
                            item.AddTime = DateTime.Now;
                        }
                        _billInvflow.InsertRange(_mapper.Map<List<BillInvflow>>(enterDepotstocklist));

                        //TODO:暂未处理甲方管理系统相关内容
                        //var list = new List<BillPushinfo>();
                        //string pushtype = FackbeekType.InterfaceType_HJ_1F_StockIn.ToString();
                        //if (stock.IsBack)
                        //{
                        //    pushtype = FackbeekType.InterfaceType_HJ_2F_BackStockIn.ToString();
                        //}
                        //else if (stock.IsSurplus)
                        //{
                        //    pushtype = FackbeekType.InterfaceType_HJ_2F_LeftStockIn.ToString();
                        //}
                        ////else if()
                        ////回调数据
                        //foreach (var item in stocklist)
                        //{
                        //    list.Add(new BillPushinfo
                        //    {
                        //        DocsNo = stock.ExecDocsNo,
                        //        TypeCode = pushtype,
                        //        RFIDBarCode = stock.ContGrpBarCode,
                        //        HWBarCode = stock.ContGrpBarCode,
                        //        CLBarCode = item.CLBarCode,
                        //        WarehouseId = warehouse.Id,
                        //        WarehouseCode = warehouse.Code,
                        //        WareCellId = 0,
                        //        WareCellCode = task.AddrTo,
                        //        MatId = item.MatId,
                        //        MatCode = item.MatCode,
                        //        MatName = item.MatName,
                        //        TolWQty = item.TolWQty,
                        //        NetWQty = item.NetWQty,
                        //        TareWQty = item.TareWQty,
                        //        ReqNo = Guid.NewGuid().ToString()
                        //    });
                        //}
                        //if (stock.ContGrpType == ContGrpType.Material.GetHashCode())
                        //{
                        //    _billPushinforepository.InsertRange(list);
                        //}
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                        result.ResMsg = task.ID + "完成任务异常";
                        _logger.LogInformation("完成任务异常" + ex.ToString());
                    }

                    break;

                case TaskType.OutDepot:
                    //验证库存信息
                    var stocklist = _billInvnowrepository.GetList(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                    if (stocklist == null || !stocklist.Any())
                    {
                        result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return result;
                    }
                    var flowlist = _mapper.Map<List<BillInvflow>>(stocklist);
                    foreach (var item in flowlist)
                    {
                        item.Id = IdFactory.NewId();
                        item.InvStateCode = InvState.InvEcecState_Out.ToString();
                        item.AddTime = DateTime.Now;
                        item.Memo = "任务完成";
                    }
                    try
                    {
                        _db.BeginTran();
                        //删除库存及条码信息
                        _billInvnowrepository.Delete(p => stocklist.Select(p => p.Id).ToList().Contains(p.Id));
                        _billInvinitrepository.Delete(p => p.ContGrpBarCode == task.BarCode);
                        //更新货位信息
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = LocationState.LocationState_Empty.GetHashCode(),
                            ContGrpBarCode = "",
                            ContGrpId = 0,
                            EditTime = DateTime.Now
                        }, p => p.StateNum == LocationState.LocationState_StockOut.GetHashCode() && p.ContGrpId == flowlist.First().ContGrpId && p.Code.Contains(task.AddrFrom));

                        //更新流水信息
                        _billInvflow.InsertRange(flowlist);
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        _logger.LogInformation(ex.ToString());
                        result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                        result.ResMsg = task.ID + "完成任务异常";
                    }
                    break;

                case TaskType.TransferDepot:

                    var fromcell = _basewarecellrepository.GetFirst(p => p.Code == task.AddrFrom);
                    var grcontid = fromcell.ContGrpId;
                    var grcontcode = fromcell.ContGrpBarCode;
                    var fromcellno = fromcell.Code;
                    var tocellno = task.AddrTo;

                    try
                    {
                        _db.BeginTran();
                        //更新货位信息
                        //起始货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = LocationState.LocationState_Empty.GetHashCode(),
                            ContGrpBarCode = "",
                            ContGrpId = 0,
                            EditTime = DateTime.Now
                        }, p => p.Code.Contains(fromcellno));
                        //目标货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = LocationState.LocationState_Full.GetHashCode(),
                            ContGrpBarCode = grcontcode,
                            ContGrpId = grcontid,
                            EditTime = DateTime.Now
                        }, p => p.Code.Contains(tocellno));

                        //更新库存信息
                        int row = int.Parse(tocellno.Split('-')[0]);
                        int col = int.Parse(tocellno.Split('-')[1]);
                        int layer = int.Parse(tocellno.Split('-')[2]);
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                        {
                            PutRow = row,
                            PutCol = col,
                            PutLayer = layer
                        }, p => p.ContGrpId == grcontid && p.InvStateCode == InvState.InvEcecState_In.ToString());

                        //更新流水信息
                        var stock = _billInvnowrepository.GetFirst(p => p.ContGrpId == grcontid && p.ContGrpBarCode == grcontcode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        var flow = _mapper.Map<BillInvflow>(stock);
                        flow.Id = IdFactory.NewId();
                        flow.AddTime = DateTime.Now;
                        flow.Memo = grcontcode + "移库(" + fromcellno + "至" + tocellno + ")";
                        _billInvflow.Insert(flow);
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                        result.ResMsg = task.ID + "完成任务异常";
                        _logger.LogInformation("完成任务异常" + ex.ToString());
                    }
                    break;

                case TaskType.Delivery:
                    break;

                case TaskType.EmptyInit:
                    break;

                default:
                    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.Fail.GetDescription();
                    return result;
            }

            return result;
        }

        #endregion 完成/取消任务
    }

    /// <summary>
    ///  主线分流
    /// </summary>
    public class MainlineDiversion
    {
        /// <summary>
        ///  任务号
        /// </summary>
        public int TaskId { get; set; }

        /// <summary>
        ///  仓库号
        /// </summary>
        public string WarehouseCode { get; set; }
    }
}