SX-WMS/wms.service/Service/FJService.cs

using AutoMapper;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using wms.dataservice.IDataSetvice;
using wms.dto;
using wms.dto.request.fj;
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.Ext;
using System.Linq;
using WCS.Entity.fj;
using wms.util.Check;

namespace wms.service.Service
{
    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;
        }
        Repository<fjSysConfig> _sysconfigrepository => new Repository<fjSysConfig>();

        ITenant _db => SqlSugarHelper.Db;//处理事务
        Repository<BaseContinfo> _baseContinfo => new Repository<BaseContinfo>();
        RepositoryTask<WCS_TaskInfo> _taskrepository => new RepositoryTask<WCS_TaskInfo>();

        Repository<BillInvnow> _billInvnowrepository => new Repository<BillInvnow>();
        Repository<BillInvinit> _billInvinitrepository => new Repository<BillInvinit>();
        Repository<BaseMatinfo> _basematerrepository => new Repository<BaseMatinfo>();
        Repository<BillSpoolTrans> _billSpoolTransrepository => new Repository<BillSpoolTrans>();
        Repository<BillBominfo> _billBominfoRepository => new Repository<BillBominfo>();
        Repository<BillBomsetinfo> _billBomsetinfoRepository => new Repository<BillBomsetinfo>();
        Repository<BillBomsetgrp> _billBomsetgrpRepository => new Repository<BillBomsetgrp>();
  
        Repository<BillDocsinfo> _billdocrepository => new Repository<BillDocsinfo>();
        RepositoryTask<WCS_TaskOld> _wcstaskoldrepository => new RepositoryTask<WCS_TaskOld>();
        Repository<BillInvflow> _billInvflow => new Repository<BillInvflow>();
        Repository<BillPushinfo> _billPushinforepository => new Repository<BillPushinfo>();
        Repository<BaseWarecell> _basewarecellrepository => new Repository<BaseWarecell>();
        Repository<BaseWarehouse> _basewarehouserepository => new Repository<BaseWarehouse>();
        RepositoryTask<WCS_TaskDtl> _taskdetailrepository => new RepositoryTask<WCS_TaskDtl>();

        Repository<BillMachinfo> _basemachinforepository => new Repository<BillMachinfo>();


        /// <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 fjSysConfig GetSysConfigByExpression(Expression<Func<fjSysConfig, bool>> WhereExpression)
        {
            return _sysconfigrepository.GetSingle(WhereExpression);
        }
     
        /// <summary>
        /// 获取反馈信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public List<BillPushinfo> GetBillPushinfoList(Expression<Func<BillPushinfo, bool>> WhereExpression)
        {
            return _billPushinforepository.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>
        /// 更新BillPushinfo表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateBillPushinfoModelColumns(UpdateModelColumns<BillPushinfo> updateModel)
        {
            return _billPushinforepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }
      
        public bool SyncMaterInfo(List<FJSyncMaterInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                item.UpdatedTime = DateTime.Now;
                if (_basematerrepository.IsAny(p => p.Code == item.MatCode))
                {
                    _basematerrepository.UpdateModelColumns(p => new BaseMatinfo() { IsHold = item.IsHold, HoldDuration = item.HoldDuration, Name = item.MatName, EditTime = DateTime.Now, Description = item.Describe },
                       p => p.Code == item.MatCode);
                }
                else
                {
                    var model = _mapper.Map<BaseMatinfo>(item);
                    model.AddTime = DateTime.Now;
                    _basematerrepository.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 WetFormulaInfo(WetFormulaInfoRequest reqDto)
        {
            var res = new SRes();
            //保存表Bill_BomInfo
            foreach (var item in reqDto.FeedList)
            {
                if (_billBominfoRepository.IsAny(p => p.Code == reqDto.FeedCode && p.MatCode == item.MatCode))
                {
                    var mat = _basematerrepository.GetSingle(p => p.Code == item.MatCode);

                    _billBominfoRepository.UpdateModelColumns(p => new BillBominfo() { MatCode = item.MatCode,MatId = mat.Id, Name = item.MatCode,  HWCountQty = item.Count, EditTime = DateTime.Now },
                       p => p.Code == reqDto.FeedCode && p.MatCode == item.MatCode);
                }
                else
                {
                    var mat = _basematerrepository.GetSingle(p => p.Code == item.MatCode);
                    if (mat == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                        return res;
                    }
                    var model = new BillBominfo() {
                     Code = reqDto.FeedCode,
                     Name = reqDto.FeedCode,
                     MatCode = item.MatCode,
                     MatId = mat.Id,
                     AddTime = DateTime.Now,
                     AddWho = "wms",
                     EditTime = DateTime.Now,
                     EditWho = "wms",
                     IsStop = 0,
                     HWCountQty = item.Count,
                     ProMatCode = reqDto.MaterialCode
                    };
                    model.AddTime = DateTime.Now;
                    _billBominfoRepository.Insert(model);
                }
            }
            return res;
        }

        /// <summary>
        /// 帘线工单信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            var res = new SRes();
            var stack = _billBomsetgrpRepository.GetModelByExpression(p => p.ProMaterCode == reqDto.MatCode && p.BomCode == reqDto.FeedCode);
            if (stack == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = reqDto.BillCode + "该单据配方没有垛型信息，请先配置垛型";
                return res;
            }
            if (reqDto.BillState == CurtainBillState.初始化.ToString() || reqDto.BillState == CurtainBillState.已排产.ToString())
            {
                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;
                    doc.BomCode = reqDto.FeedCode;
                    doc.ProMaterCode = reqDto.MatCode;
                    doc.SetGrpCode = stack.Code;
                    doc.WorkOrder = reqDto.WorkOrder;
                    var docinsert = _billdocrepository.Insert(doc);
                    if (!docinsert)
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                        return res;
                    }
                }
                _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { ProBillCode = reqDto.BillCode, ProWorkOrder = reqDto.WorkOrder, ProSetGrpCode = stack.Code, EditTime = DateTime.Now }, p => reqDto.WbList.Contains(p.MachNo));
            }
            else if (reqDto.BillState == CurtainBillState.生产中.ToString())
            {
                int state = DocState.DocState_Execute.GetHashCode();
                _billdocrepository.UpdateModelColumns(p => new BillDocsinfo() { StateNum = state }, p => p.DocsNo == reqDto.BillCode);
                _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { BillCode = reqDto.BillCode, WorkOrder = reqDto.WorkOrder, SetGrpCode = stack.Code, EditTime = DateTime.Now }, p => reqDto.WbList.Contains(p.MachNo));
            }
            else if (reqDto.BillState == CurtainBillState.生产结束.ToString()|| reqDto.BillState == CurtainBillState.计划关闭.ToString())
            {
                int state = DocState.DocState_Complete.GetHashCode();
                _billdocrepository.UpdateModelColumns(p => new BillDocsinfo() { StateNum = state }, p => p.DocsNo == reqDto.BillCode);
            }
            return res;
        }
        /// <summary>
        /// 湿拉工单启动验证
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainOrderStartCheck(CurtainOrderStartCheckRequest reqDto)
        {
            var res = new SRes();
            var doc = _billdocrepository.GetList(p => p.WorkOrder == reqDto.BillCode);
            if (doc == null || !doc.Any())
            {
                res.ResCode = 0;
                res.ResMsg = reqDto.BillCode + "工单不存在";
                return res;
            }
            if (doc.Where(p=> string.IsNullOrEmpty(p.BomCode)).Any())
            {
                res.ResCode = 0;
                res.ResMsg = reqDto.BillCode + "帘线工序工单没有配置垛型信息,请先配置垛型";
                return res;
            }
            //foreach (var item in doc)
            //{
            //    _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { BillCode = item.DocsNo, WorkOrder = item.WorkOrder, SetGrpCode = item.SetGrpCode, EditTime = DateTime.Now }, p => p.ProBillCode == item.DocsNo);
            //}
            return res;
        }
        
        /// <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;
        }

        /// <summary>
        /// 分配分拣库
        /// </summary>
        /// <returns></returns>
        public bool AllocationWarehouseSort(AllocationWarehouseSortRequest reqDto)
        {
            var list = _billSpoolTransrepository.AsQueryable().Where(p => p.WarehouseSort == 0).Take(reqDto.TaskCount).ToList();
            foreach (var item in list)
            {
                var maclist = _basemachinforepository.AsQueryable().Where(p => p.WorkOrder == item.WorkOrder);
                var warelist = maclist.Select(p => p.WarehouseCode).Distinct();
                if (!warelist.Any())
                {
                    _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans()
                    {
                        ErrType = 1,
                        ErrMsg = "没有配置机台信息",
                        EditTime = DateTime.Now
                    }, p => p.ConBarCode == item.ConBarCode);
                }
                else if (warelist.Count() == 1)
                {
                    int sort = int.Parse(warelist.First().Substring(0, 1));
                    _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans()
                    {
                        WarehouseSort = sort,
                        Direct = warelist.First().Substring(1, 1),
                        EditTime = DateTime.Now
                    }, p => p.ConBarCode == item.ConBarCode);
                }
                else
                {
                    var waretemplist = maclist.Select(p => new { p.WarehouseCode,p.WorkOrder,p.BillCode}).Distinct();
                    var warehouselist = _basewarehouserepository.GetList().Select(p => p.Code);
                    foreach (var warehouse in warehouselist)
                    {
                        var stackdetaillist = _billBomsetinfoRepository.AsQueryable();
                        getMatProport(item.MatCode, warehouse);
                    }
                    //根据垛型及库存比例分配
                    //找出该物料类型在每个库所要求的所有量
                   

                    //找出该物料库存在当前库所有
                }
            }
            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);
            if (mixrow == null || !mixrow.Any())
            {
                var matcodelist = _billBomsetinfoRepository.AsQueryable();
                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;
        }

        public decimal getMatProport(string matcode, string warehousecode)
        {
            //计算此仓库所有该物料的量
            //每的单子（每盘的数量）*预计盘数
            var stackdetaillist = _billBomsetinfoRepository.AsQueryable();
            return 0;
        }

        /// <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 = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
            if (doc == null)
            {
                doc = new BillDocsinfo();
                doc.WarehouseId = warehosue.Id;
                //保存单据信息
                doc.ReqNo = reqDto.ReqId;
                doc.DocsNo = reqDto.BillCode;
                doc.TypeNum = DocType.DocType_FJ_CurtainProductionStockOut.GetHashCode();
                doc.StateNum = DocState.DocState_Create.GetHashCode();
                doc.JsonContent = JsonConvert.SerializeObject(reqDto);
                doc.DownQty = 1;
                var docinsert = _billdocrepository.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;
        }
        public SRes ManualBuildStockTrans(ManualBuildStockTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        public SRes BomInfoTrans(BomInfoTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        /// <summary>
        /// 实时库存查询接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public GetFJCurStockListResponse GetCurStockList(GetFJCurStockListRequest reqDto)
        {
            var res = new GetFJCurStockListResponse()
            {
                ResData = new List<FJResDataItem>()
                {

                }
            };
            int totalCount = 0;
            var list = _billInvnowrepository.Context.Queryable<BillInvnow>()
                .Where(p => p.InvStateCode == InvState.InvEcecState_In.ToString())
                .WhereIF(!string.IsNullOrEmpty(reqDto.MatCode), p => p.MatCode.Contains(reqDto.MatCode))
                .WhereIF(!string.IsNullOrEmpty(reqDto.MatName), p => p.MatName.Contains(reqDto.MatName))
                .ToPageList(reqDto.PageIndex, reqDto.PageSize, ref totalCount)
                .Select(p => new FJResDataItem
                {
                    MatCode = p.MatCode,
                    MatName = p.MatName,
                    MatBarCode = p.CLBarCode,
                    Describe = "",
                    LocCell = p.PutCol.ToString(),
                    LocLayer = p.PutLayer.ToString(),
                    LocRow = p.PutRow.ToString(),
                    LocCode = p.PutRow.ToString() + p.PutCol.ToString() + p.PutLayer.ToString(),
                    ConBarCode = p.ContGrpBarCode,
                    HWBarCode = p.HWBarCode,
                    UpdatedTime = p.EditTime,
                }
                );
            res.TotalCount = totalCount;
            res.ResData = list.ToList();
            return res;
        }
    }
}