kunshan-bzfm-mes-backend/DOAN.Service/MES/Product/ProWorkorderQueryService.cs

using DOAN.Model.BZFM;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Repository;
using DOAN.Service.MES.product.IService;
using Infrastructure.Attribute;
using Infrastructure.Converter;
using Infrastructure.Extensions;

namespace DOAN.Service.MES.product
{
    /// <summary>
    /// 工单查询服务
    /// </summary>
    [AppService(
        ServiceType = typeof(IProWorkorderQueryService),
        ServiceLifetime = LifeTime.Transient
    )]
    public class ProWorkorderQueryService : BaseService<ProWorkorder>, IProWorkorderQueryService
    {
        /// <summary>
        /// 查询生产工单列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProWorkorderDto3> GetList(ProWorkorderQueryDto parm)
        {
            if (parm.WorkorderDate != null && parm.WorkorderDate.Length > 0)
            {
                parm.WorkorderDate[0] = DOANConvertDate.ConvertLocalDate(parm.WorkorderDate[0]);
                parm.WorkorderDate[1] = DOANConvertDate.ConvertLocalDate(parm.WorkorderDate[1]);
                parm.WorkorderDate[0] = parm.WorkorderDate[0].Date;
                parm.WorkorderDate[1] = parm.WorkorderDate[1].Date;
            }
            bool hasWorkorder = !string.IsNullOrEmpty(parm.Workorder);
            var predicate = Expressionable
                .Create<ProWorkorder>()
                .AndIF(hasWorkorder, it => it.Workorder.Contains(parm.Workorder))
                .AndIF(
                    !string.IsNullOrEmpty(parm.productionName),
                    it => it.productionName.Contains(parm.productionName)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.productionCode),
                    it => it.productionCode.Contains(parm.productionCode)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.MaterialCode),
                    it =>
                        it.productionCode.Contains(parm.MaterialCode)
                        || it.MaterialCode.Contains(parm.MaterialCode)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.FeedOrder),
                    it => it.FeedOrder.Contains(parm.FeedOrder)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.CustomerOrder),
                    it => it.CustomerOrder.Contains(parm.CustomerOrder)
                )
                .AndIF(!string.IsNullOrEmpty(parm.RouteCode), it => it.RouteCode == parm.RouteCode)
                .AndIF(!string.IsNullOrEmpty(parm.GroupCode), it => it.GroupCode == parm.GroupCode)
                .AndIF(
                    (parm.WorkorderDate != null && parm.WorkorderDate.Length > 0) && !hasWorkorder,
                    it =>
                        it.WorkorderDate >= parm.WorkorderDate[0]
                        && it.WorkorderDate <= parm.WorkorderDate[1]
                )
                //.And(it => it.PlanNum > 0)
                .ToExpression();

            var response = Context
                .Queryable<ProWorkorder>()
                .Where(predicate)
                .OrderBy(it => it.Sort)
                .ToPage<ProWorkorder, ProWorkorderDto3>(parm);

            return response;
        }

        /// <summary>
        /// 获取工单无校验
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProWorkorderDto> GetList_NOCheck(ProWorkorderQueryDto parm)
        {
            if (parm.WorkorderDate != null && parm.WorkorderDate.Length > 0)
            {
                parm.WorkorderDate[0] = DOANConvertDate.ConvertLocalDate(parm.WorkorderDate[0]);
                parm.WorkorderDate[1] = DOANConvertDate.ConvertLocalDate(parm.WorkorderDate[1]);
                parm.WorkorderDate[0] = parm.WorkorderDate[0].Date;
                parm.WorkorderDate[1] = parm.WorkorderDate[1].Date;
            }
            bool hasWorkorder = !string.IsNullOrEmpty(parm.Workorder);
            var predicate = Expressionable
                .Create<ProWorkorder>()
                .AndIF(
                    !string.IsNullOrEmpty(parm.productionName),
                    it => it.productionName.Contains(parm.productionName)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.productionCode),
                    it => it.productionCode.Contains(parm.productionCode)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.MaterialCode),
                    it =>
                        it.productionCode.Contains(parm.MaterialCode)
                        || it.MaterialCode.Contains(parm.MaterialCode)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.FeedOrder),
                    it => it.FeedOrder.Contains(parm.FeedOrder)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.CustomerOrder),
                    it => it.CustomerOrder.Contains(parm.CustomerOrder)
                )
                .AndIF(!string.IsNullOrEmpty(parm.RouteCode), it => it.RouteCode == parm.RouteCode)
                .AndIF(!string.IsNullOrEmpty(parm.GroupCode), it => it.GroupCode == parm.GroupCode)
                .AndIF(
                    (parm.WorkorderDate != null && parm.WorkorderDate.Length > 0) && !hasWorkorder,
                    it =>
                        it.WorkorderDate >= parm.WorkorderDate[0]
                        && it.WorkorderDate <= parm.WorkorderDate[1]
                )
                .AndIF(hasWorkorder, it => it.Workorder.Contains(parm.Workorder))
                //.And(it => it.PlanNum > 0)
                .ToExpression();

            var response = Context
                .Queryable<ProWorkorder>()
                .Where(predicate)
                .Select(
                    it => new ProWorkorderDto
                    {
                        Id = it.Id,
                        MaterialNum = (int)
                            SqlFunc.Abs(
                                SqlFunc
                                    .Subqueryable<MmRecordOutbound>()
                                    .Where(sub => sub.Workorder == it.Workorder)
                                    .Where(sub => sub.TransactionType == "领料出库")
                                    .Where(sub => sub.Remarks != "已撤销" || sub.Remarks == null)
                                    .Select(sub => sub.Quantity)
                            ),
                        Type = SqlFunc
                            .Subqueryable<MmMaterial>()
                            .Where(sub => sub.MaterialCode == it.productionCode)
                            .Select(sub => sub.Type),
                        SubType = SqlFunc
                            .Subqueryable<MmMaterial>()
                            .Where(sub => sub.MaterialCode == it.MaterialCode)
                            .Select(sub => sub.Type),
                        InInventoryNum = it.ProductNum - it.ShipmentNum,
                    },
                    true
                )
                .OrderBy(it => it.Sort)
                .ToPage(parm);
            return response;
        }

        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public ProWorkorder GetInfo(string Id)
        {
            var response = Queryable().Where(x => x.Id == Id).First();

            return response;
        }

        /// <summary>
        /// 获取工单进度跟踪列表
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public PagedInfo<ProWorkorderTranceProgressDto> GetWorkorderTraceProgressList(
            ProWorkorderQueryDto query
        )
        {
            // 这里需要实现工单进度跟踪列表的查询逻辑
            // 暂时返回空列表
            return new PagedInfo<ProWorkorderTranceProgressDto>();
        }

        /// <summary>
        /// 查询BOM 及其所需数量
        /// </summary>
        /// <param name="workorder_num"></param>
        /// <returns></returns>
        public List<WorkOrderBom> SearchBOMNum(string workorder_num)
        {
            // 这里需要实现BOM查询逻辑
            // 暂时返回空列表
            return new List<WorkOrderBom>();
        }

        /// <summary>
        /// 获取工单生产进度
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns></returns>
        public int GetWorkorderWithProgress(string workorder)
        {
            var workorderInfo = Context
                .Queryable<ProWorkorder>()
                .Where(it => it.Workorder == workorder)
                .First();
            if (workorderInfo == null)
            {
                throw new Exception("工单不存在");
            }
            var reportInfo = Context
                .Queryable<ProReportwork01>()
                .Where(it => it.Workorder == workorder)
                .OrderByDescending(it => it.ProcessId)
                .First();
            if (reportInfo == null)
            {
                return 1;
            }
            return reportInfo.ProcessId;
        }

        /// <summary>
        /// 获取审批通知列表
        /// </summary>
        /// <param name="parm">查询参数</param>
        /// <returns></returns>
        public PagedInfo<ProWorkorderApprovalDto> GetApprovalList(ProWorkorderApprovalQueryDto parm)
        {
            var result = Context
                .Queryable<QcScrapRecords>()
                .Where(it => it.Status == "待审批")
                .OrderByDescending(it => it.CreatedTime)
                .Select(it => new ProWorkorderApprovalDto
                {
                    Id = it.Id,
                    CreateTime = it.CreatedTime.Value,
                    Workorder = it.Workorder,
                    ProductionCode = it.ProductCode,
                    ProductionName = it.ProductName,
                    BatchNo = it.BatchNo,
                    StoveCode = it.StoveCode,
                    Operator = it.Operator,
                    Type = SqlFunc
                        .Subqueryable<MmMaterial>()
                        .Where(sub => sub.MaterialCode == it.ProductCode)
                        .Select(sub => sub.Type),
                    Content = $"有不良品待审批",
                })
                
                .ToPage(parm);
            // 业务逻辑留空，暂时返回空列表
            return result;
        }

        /// <summary>
        /// 获取滞留库存列表
        /// </summary>
        /// <param name="parm">查询参数</param>
        /// <returns></returns>
        public PagedInfo<ProWorkorderStockDto> GetStockList(ProWorkorderStockQueryDto parm)
        {
            var result = Context
                .Queryable<ProWorkorder>()
                .WhereIF(!string.IsNullOrEmpty(parm.ProductionCode),it=> it.productionCode == parm.ProductionCode)
                .Where(it => (it.ProductNum - it.ShipmentNum) > 0)
                .OrderByDescending(it => it.CreatedTime)
                .Select(it => new ProWorkorderStockDto
                {
                    Id = it.Id,
                    Workorder = it.Workorder,
                    ProductionCode = it.productionCode,
                    ProductionName = it.productionName,
                    Type = SqlFunc
                        .Subqueryable<MmMaterial>()
                        .Where(sub => sub.MaterialCode == it.productionCode)
                        .Select(sub => sub.Type),
                    BatchNo = it.FeedOrder,
                    StoveCode = it.StoveCode,
                    Operator = it.CreatedBy,
                    Content = $"有成品待出库",
                    StockQuantity = (it.ProductNum - it.ShipmentNum),
                    CreateTime = it.WorkorderDate.Value,
                })
                .ToPage(parm);

            return result;
        }
    }
}