ZT-FJ-WMS/wms.sqlsugar/Repository.cs

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using wms.dto;
using wms.dto.request.hj;
using wms.dto.request.hj.dto;
using wms.sqlsugar.model;
using wms.sqlsugar.model.hj;
using wms.util.Check;
using static wms.dto.request.hj.dto.ReportResponse;

namespace wms.sqlsugar
{
    /// <summary>
    /// 创建仓储
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Repository<T> : SimpleClient<T> where T : BaseModel, new()
    {
        public Repository()
        {
            //固定数据库用法
            base.Context = SqlSugarHelper.Db.GetConnectionScopeWithAttr<T>();

            //动态库用法一般用于维护数据库连接字符串根据用法
            //if (!SqlSugarHelper.Db.IsAnyConnection("用户读出来的数据库ConfigId")) 
            //{
            //    SqlSugarHelper.Db.AddConnection(new ConnectionConfig() { 数据库读出来信息 });
            //}
            //base.Context = SqlSugarHelper.Db.GetConnectionScope("用户读出来的数据库ConfigId");
        }
        public T InsertReturnEntity(T t)
        {
            t = CheckId.InitId<T>(t);
            return base.Context.Insertable(t).ExecuteReturnEntity();
        }
        /// <summary>
        /// 该方法默认不更新CreatedUserId，CreatedTime
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool UpdateEntity(T entity)
        {
            return base.Context.Updateable(entity).IgnoreColumns(new string[] { "CreatedUserId", "CreatedTime", "CreatedUserName" }).ExecuteCommand() > 0;
        }
        public bool UpdateModelColumns(Expression<Func<T, T>> Columns, Expression<Func<T, bool>> WhereExpression)
        {
            return base.Update(Columns, WhereExpression);
        }

        /// <summary>
        ///  更新指定列数据，并返回受影响行数
        /// </summary>
        /// <param name="Columns"></param>
        /// <param name="WhereExpression"></param>
        /// <returns></returns>
        public int UpdateModelColumnsCommands(Expression<Func<T, T>> Columns, Expression<Func<T, bool>> WhereExpression)
        {
            return Context.Updateable<T>().SetColumns(Columns).Where(WhereExpression).ExecuteCommand();
        }
        public T GetModelByExpression(Expression<Func<T, bool>> WhereExpression)
        {
            return base.GetSingle(WhereExpression);
        }
        public bool UpdateStatus(long id, int status, long userId)
        {
            return base.Context.Updateable<T>().SetColumns(it => new T()
            {
                //Status = status, UpdatedTime = DateTime.Now
            }).Where(it => it.Id == id).ExecuteCommand() > 0;
        }
        public List<hjSysConfig> GetTunList(TunnelRequest request)
        {
            var list = base.Context.Queryable<hjSysConfig>()
                       .WhereIF(!string.IsNullOrEmpty(request.WareHouse), p => p.Default2 == request.WareHouse)
                       .WhereIF(!string.IsNullOrEmpty(request.Tunnel), p => p.Default1 == request.Tunnel)
                       .WhereIF(!string.IsNullOrEmpty(request.type), p => p.Default2 == request.type)
                       .ToList();
            return list;
        }
        public bool UpdateTunStatu(long id, string statu, long userId)
        {
            return base.Context.Updateable<hjSysConfig>().SetColumns(it => new hjSysConfig()
            {
                SContent = statu,
                EditTime = DateTime.Now
            }).Where(it => it.Id == id).ExecuteCommand() > 0;
        }
        public (List<hjBaseWarehouse>, int) GetPageWareHouseList(QuertRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBaseWarehouse>()
                       .WhereIF(!string.IsNullOrEmpty(request.Code), p => p.Code.Contains(request.Code))
                       .WhereIF(!string.IsNullOrEmpty(request.Name), p => p.Name.Contains(request.Name))
                       .WhereIF(!string.IsNullOrEmpty(request.WareState), p => p.WareState == request.WareState)
                       .WhereIF(!string.IsNullOrEmpty(request.FactoryNo), p => p.FactoryNo == request.FactoryNo)
                       .WhereIF(!string.IsNullOrEmpty(request.WareType), p => p.WareType == request.WareType)
                       .ToPageList(request.PageIndex, request.PageSize, ref count);

            return (list.ToList(), count);
        }
        public (List<hjBaseWareZone>, int) GetPageWareZoneList(WareZoneRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBaseWareZone>()
                       .WhereIF(!string.IsNullOrEmpty(request.Code), p => p.Code.Contains(request.Code))
                       .WhereIF(!string.IsNullOrEmpty(request.Name), p => p.Name.Contains(request.Name))
                       .WhereIF(request.WareId > Const.Zero, p => p.WareId == request.WareId)
                       .WhereIF(!string.IsNullOrEmpty(request.WZoneState), p => p.WZoneState == request.WZoneState)
                       .ToPageList(request.PageIndex, request.PageSize, ref count);

            return (list.ToList(), count);
        }
        public (List<hjBaseWareLocation>, int) GetPageWareLocationList(WareLocationRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBaseWareLocation>()
                       .WhereIF(!string.IsNullOrEmpty(request.Code), p => p.Code.Contains(request.Code))
                       .WhereIF(!string.IsNullOrEmpty(request.Name), p => p.Name.Contains(request.Name))
                       .WhereIF(request.LocationType > Const.MinOne, p => p.LocationType == request.LocationType)
                       .WhereIF(request.Tunnel > Const.Zero, p => p.Tunnel == request.Tunnel)
                       .WhereIF(!string.IsNullOrEmpty(request.WareCode), p => p.WareCode.Contains(request.WareCode))
                       .ToPageList(request.PageIndex, request.PageSize, ref count);

            return (list.ToList(), count);
        }
        public (List<hjBaseUnits>, int) GetPageUnitList(BaseUnitRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBaseUnits>()
                       .WhereIF(!string.IsNullOrEmpty(request.Code), p => p.Code.Contains(request.Code))
                       .WhereIF(!string.IsNullOrEmpty(request.Name), p => p.Name.Contains(request.Name))
                       .WhereIF(!string.IsNullOrEmpty(request.PrimaryUnit), p => p.PrimaryUnit.Contains(request.PrimaryUnit))
                       .WhereIF(!string.IsNullOrEmpty(request.DeputyUnit), p => p.DeputyUnit.Contains(request.DeputyUnit))
                       .ToPageList(request.PageIndex, request.PageSize, ref count);

            return (list.ToList(), count);
        }
        public (List<hjBaseMater>, int) GetPageMaterList(BaseMaterRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBaseMater>()
                       .WhereIF(!string.IsNullOrEmpty(request.Code), p => p.Code.Contains(request.Code))
                       .WhereIF(!string.IsNullOrEmpty(request.Name), p => p.Name.Contains(request.Name))
                       .WhereIF(request.HoldDuration > Const.Zero, p => p.HoldDuration == request.HoldDuration)
                       .WhereIF(request.PlatingWeight > Const.Zero, p => p.PlatingWeight == request.PlatingWeight)
                       .WhereIF(!string.IsNullOrEmpty(request.Strength), p => p.Strength.Contains(request.Strength))
                       .WhereIF(!string.IsNullOrEmpty(request.Plating), p => p.Plating.Contains(request.Plating))
                       .ToPageList(request.PageIndex, request.PageSize, ref count);

            return (list.ToList(), count);
        }
        public (List<hjBillBarcode>, int) GetPageBarCodeList(BaseBarCodeRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillBarcode>()
                       .WhereIF(!string.IsNullOrEmpty(request.MatCode), p => p.MatCode.Contains(request.MatCode))
                       .WhereIF(!string.IsNullOrEmpty(request.HWBarCode), p => p.HWBarCode.Contains(request.HWBarCode))
                       .WhereIF(!string.IsNullOrEmpty(request.RFIDBarCode), p => p.RFIDBarCode.Contains(request.RFIDBarCode))
                       .ToPageList(request.PageIndex, request.PageSize, ref count);

            return (list.ToList(), count);
        }
        public (List<MaterReportResponse>, int, decimal) GetPageMaterInAndOutReportList(ReportRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillContainer, hjBillTaskHistory, hjBaseWarehouse>((container, taskHistory, house) => new object[]
            {
               JoinType.Inner, container.ContGrpId == taskHistory.ContGrpId,
               JoinType.Inner, taskHistory.WareCode == house.Code
            })
            .WhereIF(!string.IsNullOrEmpty(request.RFID), (container, taskHistory, house) => taskHistory.ContGrpBarCode.Contains(request.RFID))
            .WhereIF(!string.IsNullOrEmpty(request.HWSpec), (container, taskHistory, house) => container.HWSpec == request.HWSpec)
            .WhereIF(!string.IsNullOrEmpty(request.Grade), (container, taskHistory, house) => container.Grade == request.Grade)
            .WhereIF(!string.IsNullOrEmpty(request.ExecDocsNo), (container, taskHistory, house) => container.ExecDocsNo.Contains(request.ExecDocsNo))
            .WhereIF(!string.IsNullOrEmpty(request.PutLocNo), (container, taskHistory, house) => container.PutLocNo.Contains(request.PutLocNo))
            .WhereIF(request.TaskCode > Const.Zero, (container, taskHistory, house) => taskHistory.TaskCode == request.TaskCode)
            .WhereIF(!string.IsNullOrEmpty(request.Tunnel), (container, taskHistory, house) => taskHistory.Tunnel == request.Tunnel)
            .WhereIF(!string.IsNullOrEmpty(request.StartPoint), (container, taskHistory, house) => taskHistory.StartPoint == request.StartPoint)
            .WhereIF(!string.IsNullOrEmpty(request.EndPoint), (container, taskHistory, house) => taskHistory.EndPoint == request.EndPoint)
            .Select((container, taskHistory, house) => new MaterReportResponse()
            {
                RFID = container.ContGrpBarCode,
                ContGrpBarCode = container.ContGrpBarCode,
                ExecState = container.ExecState.ToString(),
                ExecDocsNo = container.ExecDocsNo,
                ExecDocsRowNo = container.ExecDocsRowNo,
                CustNo = container.CustCode,
                CustName = container.CustName,
                PutRow = container.PutRow,
                PutCol = container.PutCol,
                PutLayer = container.PutLayer,
                PutLocNo = container.PutLocNo,
                InvBarCode = container.InvBarCode,
                InvState = container.InvState,
                InDocsNo = container.InDocsNo,
                InDocsRowNo = container.InDocsRowNo,
                SuppCode = container.SuppCode,
                SuppName = container.SuppName,
                WareHouseName = house.Name,
                ProductTime = container.ProductTime,
                RFIDBarCode = container.RFIDBarCode,
                HWSpec = container.HWSpec,
                IsSurplus = container.IsSurplus,
                IsRework = container.IsRework,
                IsFast = container.IsFast,
                IsFail = container.IsFail,
                FailReason = container.FailReason,
                Grade = container.Grade,
                IsBack = container.IsBack,
                BackReason = container.Reason,
                ProductWbNo = container.ProductWbNo,
                ProductLineNo = container.ProductLineNo
            })
            .ToPageList(request.PageIndex, request.PageSize, ref count);
            decimal pro = list.Sum(p => p.TotalWtQty);  //临时计算总重量
            //list = list.Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize).ToList();
            return (list.ToList(), count, pro);
        }
        public (List<RealTimeInventoryReportResponse>, int, decimal) GetPageRealTimeInventoryReportList(ReportRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillContainer, hjBaseWarehouse, hjBaseWareLocation, hjBaseMater>((container, house, location, mater) => new object[]
            {
               JoinType.Left, container.WarehouseId == house.Id,
               JoinType.Left, house.Code == location.WareCode,
               JoinType.Left, container.MatId == mater.Id
            })
            .WhereIF(!string.IsNullOrEmpty(request.ContGrpBarCode), (container, house, location, mater) => container.ContGrpBarCode.Contains(request.ContGrpBarCode))
            .WhereIF(!string.IsNullOrEmpty(request.InvBarCode), (container, house, location, mater) => container.InvBarCode.Contains(request.InvBarCode))
            .WhereIF(!string.IsNullOrEmpty(request.Location), (container, house, location, mater) => location.Code.Contains(request.Location))
            .WhereIF(!string.IsNullOrEmpty(request.MatCode), (container, house, location, mater) => mater.Code.Contains(request.MatCode))
            .OrderBy((container, house, location, mater) => container.OneInTime, OrderByType.Asc)
            .Select((container, house, location, mater) => new RealTimeInventoryReportResponse()
            {
                ContGrpBarCode = container.ContGrpBarCode,
                WareHouseName = house.Name,
                InvBarCode = container.InvBarCode,
                HWSpec = container.HWSpec,
                MatCode = mater.Code,
                Grade = container.Grade,
                SilkType = container.SilkType,
                TotalWtQty = container.TotalWtQty,
                NetWQty = container.NetWQty,
                TareWQty = container.TareWQty,
                LengthQty = container.LengthQty,
                InvState = container.InvState,
                IsSurplus = container.IsSurplus,
                IsRework = container.IsRework,
                IsFast = container.IsFast,
                IsBack = container.IsBack,
                BackReason = container.Reason,
                IsFail = container.IsFail,
                FailReason = container.FailReason,
                ProductTime = container.ProductTime,
                OneInTime = container.OneInTime,
                InDocsNo = container.InDocsNo,
                InDocsRowNo = container.InDocsRowNo,
                PutRow = container.PutRow,
                PutCol = container.PutCol,
                PutLayer = container.PutLayer,
                PutLocNo = container.PutLocNo,
                SuppCode = container.SuppCode,
                SuppName = container.SuppName,
                CustNo = container.CustCode,
                CustName = container.CustName,
                RFIDBarCode = container.RFIDBarCode,
                Tunnel = location.Tunnel.ToString(),
                Location = location.Code,

            })
            .ToPageList(request.PageIndex, request.PageSize, ref count);
            decimal pro = list.Sum(p => p.TotalWtQty);  //临时计算总重量
            //list = list.Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize).ToList();
            return (list.ToList(), count, pro);
        }
        public (List<InventoryAgingReportResponse>, int) GetPageInventoryAgingReportList(ReportRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillContainer, hjBaseWarehouse, hjBaseWareLocation, hjBaseMater>((container, house, location, mater) => new object[]
            {
               JoinType.Left, container.WarehouseId == house.Id,
               JoinType.Left, house.Code == location.WareCode,
               JoinType.Left, container.MatId == mater.Id
            })
            .WhereIF(!string.IsNullOrEmpty(request.RFID), (container, house, location, mater) => container.RFIDBarCode.Contains(request.RFID))
            .WhereIF(!string.IsNullOrEmpty(request.HWSpec), (container, house, location, mater) => container.HWSpec == request.HWSpec)
            .WhereIF(!string.IsNullOrEmpty(request.Tunnel), (container, house, location, mater) => location.Tunnel == int.Parse(request.Tunnel))
            .WhereIF(!string.IsNullOrEmpty(request.MatCode), (container, house, location, mater) => mater.Code.Contains(request.MatCode))
            .WhereIF(!string.IsNullOrEmpty(request.Grade), (container, house, location, mater) => container.Grade == request.Grade)
            .WhereIF(request.HoldDuration != null && request.HoldDuration > 0, (container, house, location, mater) => mater.HoldDuration == request.HoldDuration)
            .GroupBy((container, house, location, mater) => new
            {
                RFIDBarCode = container.RFIDBarCode,
                HWSpec = container.HWSpec,
                MatCode = mater.Code,
                MatName = mater.Name,
                Grade = container.Grade,
                ProductTime = container.ProductTime,
                HoldDuration = mater.HoldDuration,
                Tunnel = location.Tunnel.ToString()
            })
            .Select((container, house, location, mater) => new InventoryAgingReportResponse()
            {
                RFIDBarCode = container.RFIDBarCode,
                HWSpec = container.HWSpec,
                MatCode = mater.Code,
                MatName = mater.Name,
                Grade = container.Grade,
                ProductTime = container.ProductTime,
                HoldDuration = mater.HoldDuration,
                Tunnel = location.Tunnel.ToString()
                //Remaindays = (decimal)(container.ProductTime.AddDays((double)mater.HoldDuration) - DateTime.Now).TotalHours
                //Duedate = container.ProductTime.AddDays((double)mater.HoldDuration)

            })
            .ToPageList(request.PageIndex, request.PageSize, ref count);
            //list = list.Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize).ToList();
            return (list.ToList(), count);
        }
        public (List<TaskRsponse>, int) GetPageTaskList(TaskRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillTask, hjBaseWarehouse>((task, house) => new object[]
            {
               JoinType.Inner, task.WareCode == house.Code
            })
            .WhereIF(request.TaskCode > Const.Zero, (task, house) => task.TaskCode == request.TaskCode)
            .WhereIF(request.TaskType > Const.Zero, (task, house) => task.TaskType == request.TaskType)
            .WhereIF(request.TaskState > Const.Zero, (task, house) => task.TaskState == request.TaskState)
            .WhereIF(request.Tunnel > Const.Zero, (task, house) => task.Tunnel == request.Tunnel)
            .WhereIF(!string.IsNullOrEmpty(request.BusType), (task, house) => task.BusType.Contains(request.BusType))
            .WhereIF(!string.IsNullOrEmpty(request.WareCode), (task, house) => task.WareCode.Contains(request.WareCode))
            .WhereIF(!string.IsNullOrEmpty(request.ContGrpBarCode), (task, house) => task.ContGrpBarCode.Contains(request.ContGrpBarCode))
            .WhereIF(!string.IsNullOrEmpty(request.EndPoint), (task, house) => task.EndPoint.Contains(request.EndPoint))
            .WhereIF(!string.IsNullOrEmpty(request.StartPoint), (task, house) => task.StartPoint.Contains(request.StartPoint))
            .WhereIF(!string.IsNullOrEmpty(request.DocCode), (task, house) => task.DocCode.Contains(request.DocCode))
            .Select((task, house) => new TaskRsponse()
            {
                Id = task.Id,
                TaskCode = task.TaskCode,
                TaskType = task.TaskType,
                TaskState = task.TaskState,
                Tunnel = task.Tunnel,
                ContGrpBarCode = task.ContGrpBarCode,
                EndPoint = task.EndPoint,
                StartPoint = task.StartPoint,
                BusType = task.BusType,
                WareCodeName = house.Name,
                Priority = task.Priority,
                EquNo = task.EquNo,
                Srm = task.SrmNo,
                CurPoint = task.CurPoint,
                NextPoint = task.NextPoint,
                Qty = task.Qty,
                DocCode = task.DocCode,
                IsManual = task.IsManual,
                IsEmpty = task.IsEmpty,

                AddWho = task.AddWho,
                EditWho = task.EditWho,
                AddTime = task.AddTime,
                EditTime = task.EditTime
            })
            .ToPageList(request.PageIndex, request.PageSize, ref count);
            //list = list.Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize).ToList();
            return (list.ToList(), count);
        }
        public (List<TaskRsponse>, int) GetPageTaskHistoryList(TaskRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillTaskHistory, hjBaseWarehouse>((taskHistory, house) => new object[]
            {
               JoinType.Inner, taskHistory.WareCode == house.Code
            })
            .WhereIF(request.TaskCode > Const.Zero, (taskHistory, house) => taskHistory.TaskCode == request.TaskCode)
            .WhereIF(request.TaskType > Const.Zero, (taskHistory, house) => taskHistory.TaskType == request.TaskType)
            .WhereIF(request.TaskState > Const.Zero, (taskHistory, house) => taskHistory.TaskState == request.TaskState)
            .WhereIF(request.Tunnel > Const.Zero, (taskHistory, house) => taskHistory.Tunnel == request.Tunnel.ToString())
            .WhereIF(!string.IsNullOrEmpty(request.BusType), (taskHistory, house) => taskHistory.BusType.Contains(request.BusType))
            .WhereIF(!string.IsNullOrEmpty(request.WareCode), (taskHistory, house) => taskHistory.WareCode.Contains(request.WareCode))
            .WhereIF(!string.IsNullOrEmpty(request.ContGrpBarCode), (taskHistory, house) => taskHistory.ContGrpBarCode.Contains(request.ContGrpBarCode))
            .WhereIF(!string.IsNullOrEmpty(request.EndPoint), (taskHistory, house) => taskHistory.EndPoint.Contains(request.EndPoint))
            .WhereIF(!string.IsNullOrEmpty(request.StartPoint), (taskHistory, house) => taskHistory.StartPoint.Contains(request.StartPoint))
            .WhereIF(!string.IsNullOrEmpty(request.DocCode), (taskHistory, house) => taskHistory.DocCode.Contains(request.DocCode))
            .Select((taskHistory, house) => new TaskRsponse()
            {
                Id = taskHistory.Id,
                TaskCode = taskHistory.TaskCode,
                TaskType = taskHistory.TaskType,
                TaskState = taskHistory.TaskState,
                Tunnel = int.Parse(taskHistory.Tunnel),
                ContGrpBarCode = taskHistory.ContGrpBarCode,
                EndPoint = taskHistory.EndPoint,
                StartPoint = taskHistory.StartPoint,
                BusType = taskHistory.BusType,
                WareCodeName = house.Name,
                Priority = taskHistory.Priority,
                EquNo = taskHistory.EquNo,
                Srm = taskHistory.SrmNo,
                CurPoint = taskHistory.CurPoint,
                NextPoint = taskHistory.NextPoint,
                Qty = taskHistory.Qty,
                DocCode = taskHistory.DocCode,
                IsManual = int.Parse(taskHistory.IsManual),
                IsEmpty = int.Parse(taskHistory.IsEmpty),

                AddWho = taskHistory.AddWho,
                EditWho = taskHistory.EditWho,
                AddTime = taskHistory.AddTime,
                EditTime = taskHistory.EditTime
            })
            .ToPageList(request.PageIndex, request.PageSize, ref count);
            //list = list.Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize).ToList();
            return (list.ToList(), count);
        }
        public (List<RealTimeInventoryReportResponse>, int, decimal) GetPageStockdetailList(StockRequest request)
        {
            int count = 0;
            var list = base.Context.Queryable<hjBillContainer, hjBaseWarehouse, hjBaseWareLocation, hjBaseMater>((stock, house, location, mater) => new object[]
            {
                JoinType.Left, stock.WarehouseId == house.Id,
                JoinType.Left, house.Id == location.WareId,
                JoinType.Left, stock.MatId == mater.Id
            })
            .Where((stock, house, location, mater) => house.WareState == Const.One.ToString()
            && location.LocationState == LocationState.LocationState_Full.GetHashCode() && location.LocationType == LocationType.LocationType_StorageLocation.GetHashCode()
            && stock.ExecState == InvState.InvEcecState_In.GetHashCode() && stock.ContGrpId == location.ContGrpID)
            .WhereIF(!string.IsNullOrEmpty(request.Grade), (stock, house, location, mater) => stock.Grade == request.Grade)
            .WhereIF(!string.IsNullOrEmpty(request.Location), (stock, house, location, mater) => location.Code.Contains(request.Location))
            .WhereIF(!string.IsNullOrEmpty(request.MatCode), (stock, house, location, mater) => mater.Code.Contains(request.MatCode))
            .WhereIF(!string.IsNullOrEmpty(request.ContGrpBarCode), (stock, house, location, mater) => stock.ContGrpBarCode.Contains(request.ContGrpBarCode))
            .WhereIF(!string.IsNullOrEmpty(request.HWSpec), (stock, house, location, mater) => stock.HWSpec == request.HWSpec)
            .WhereIF(request.HoldDuration > 0, (stock, house, location, mater) => mater.HoldDuration == request.HoldDuration)
            .Select((stock, house, location, mater) => new RealTimeInventoryReportResponse()
            {
                ContGrpBarCode = stock.ContGrpBarCode,
                ExecState = stock.ExecState.ToString(),
                ExecDocsNo = stock.ExecDocsNo,
                ExecDocsRowNo = stock.ExecDocsRowNo,
                ExecDocsTypeCode = stock.ExecDocsTypeCode,
                MatCode = mater.Code,
                MatName = mater.Name,
                Location = location.Code,
                Tunnel = location.Tunnel.ToString(),
                CustNo = stock.CustCode,
                CustName = stock.CustName,
                WareHouseName = house.Name,
                InvBarCode = stock.InvBarCode,
                InvState = stock.InvState,
                InDocsNo = stock.InDocsNo,
                InDocsRowNo = stock.InDocsRowNo,
                SuppCode = stock.SuppCode,
                SuppName = stock.SuppName,
                RowStop = location.RowStop,
                TotalWtQty = stock.TotalWtQty,
                NetWQty = stock.NetWQty,
                TareWQty = stock.TareWQty,
                LengthQty = stock.LengthQty,
                BatchNo = stock.Batch,
                ProductTime = stock.ProductTime,
                OneInTime = stock.OneInTime,
                RFIDBarCode = stock.RFIDBarCode,
                HWSpec = stock.HWSpec,
                IsSurplus = stock.IsSurplus,
                IsRework = stock.IsRework,
                IsFast = stock.IsFast,
                IsFail = stock.IsFail,
                FailReason = stock.FailReason,
                Grade = stock.Grade,
                IsBack = stock.IsBack,
                BackReason = stock.Reason,
                ProductWbNo = stock.ProductWbNo,
                ProductLineNo = stock.ProductLineNo,

            })
            .ToPageList(request.PageIndex, request.PageSize, ref count);
            decimal total = list.Sum(p => p.TotalWtQty);
            //list = list.Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize).ToList();
            return (list.ToList(), count, total);
        }
    }
}