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

using System.Collections.Generic;
using DOAN.Model.BZFM;
using DOAN.Model.MES.order;
using DOAN.Model.MES.order.Dto;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Model.Mobile.Dto;
using DOAN.Service.MES.product.IService;
using DOAN.Service.Mobile;
using Infrastructure.Attribute;
using MailKit.Search;
using Microsoft.IdentityModel.Tokens;
using SqlSugar.DistributedSystem.Snowflake;

namespace DOAN.Service.MES.product
{
    /// <summary>
    /// 工单物料服务实现
    /// </summary>
    [AppService(
        ServiceType = typeof(IProWorkorderMaterialService),
        ServiceLifetime = LifeTime.Transient
    )]
    public class ProWorkorderMaterialService
        : BaseService<ProWorkorder>,
            IProWorkorderMaterialService
    {
        /// <summary>
        /// 根据工单号查询工单已领料清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>领料清单数据</returns>
        public List<MaterialTakeDto> GetMaterialTakeList(string workorder)
        {
            var result = Context
                .Queryable<MmRecordOutbound>()
                .Where(it => it.Workorder == workorder)
                .Where(it => it.TransactionType == "领料出库")
                .Where(it => it.Remarks != "已撤销")
                .Select(it => new MaterialTakeDto
                {
                    Id = it.Id,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    SupplierCode = it.SupplierCode,
                    SupplierName = it.SupplierName,
                    BatchNo = it.BatchNo,
                    Quantity = it.Quantity,
                    Unit = it.Unit,
                    CreatedTime = it.CreatedTime.Value,
                    Operator = it.Operator,
                    OutboundNo = it.OutboundNo,
                    Workorder = it.Workorder,
                    WorkorderRaw = it.WorkorderRaw,
                })
                .ToList();
            return result;
        }

        /// <summary>
        /// 根据工单号查询工单已成品入库清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>成品入库清单数据</returns>
        public List<ProductStorageDto> GetProductStorageList(string workorder)
        {
            var result = Context
                .Queryable<MmRecordInbound>()
                .Where(it => it.Workorder == workorder)
                .Where(it => it.TransactionType == "生产入库")
                .Where(it => it.Remarks != "已撤销")
                .Select(it => new ProductStorageDto
                {
                    Id = it.Id,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    BatchNo = it.BatchNo,
                    Quantity = it.Quantity,
                    Unit = it.Unit,
                    CreatedTime = it.CreatedTime.Value,
                    Operator = it.Operator,
                    InboundNo = it.InboundNo,
                    Workorder = it.Workorder,
                    WorkorderRaw = it.WorkorderRaw,
                })
                .ToList();
            return result;
        }

        /// <summary>
        /// 根据工单号查询工单已出货清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>出货清单数据</returns>
        public List<ShipmentDto> GetShipmentList(string workorder)
        {
            var result = Context
                .Queryable<MmRecordOutbound>()
                .Where(it => it.Workorder == workorder)
                .Where(it => it.TransactionType == "出货出库")
                .Where(it => it.Remarks != "已撤销")
                .Select(it => new ShipmentDto
                {
                    Id = it.Id,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    BatchNo = it.BatchNo,
                    Quantity = it.Quantity,
                    Unit = it.Unit,
                    CreatedTime = it.CreatedTime.Value,
                    Operator = it.Operator,
                    OutboundNo = it.OutboundNo,
                    Workorder = it.Workorder,
                    WorkorderRaw = it.WorkorderRaw,
                    CustomerOrder = it.OrderNo,
                })
                .ToList();
            return result;
        }

        /// <summary>
        /// 根据工单查询物料库存接口
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>物料库存信息列表</returns>
        public List<MaterialInventoryDto> GetMaterialInventoryList(string workorder)
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(workorder))
                {
                    throw new ArgumentNullException(nameof(workorder), "工单号不能为空");
                }

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单号不存在", nameof(workorder));
                }
                var result = new List<MaterialInventoryDto>();
                // 单原材料
                if (workorderInfo.RouteCode != "10")
                {
                    var materialCode = workorderInfo.MaterialCode;
                    var InventoryList = Context
                        .Queryable<MmInventory>()
                        .Where(it => it.MaterialCode == materialCode)
                        .Where(it => it.LocationCode == "YCL001")
                        .Where(it => it.CurrentQty > 0)
                        .Select(it => new MaterialInventoryDto
                        {
                            MaterialId = it.Id,
                            MaterialCode = it.MaterialCode,
                            MaterialName = it.MaterialName,
                            CurrentQuantity = it.CurrentQty,
                            SupplierCode = it.SupplierCode,
                            SupplierName = it.SupplierName,
                            Unit = it.Unit,
                            BatchNo = it.BatchNo,
                        })
                        .OrderBy(it => it.MaterialCode)
                        .ToList();
                    result = InventoryList;
                }
                else
                {
                    //组合材料
                    var bomList = Context
                        .Queryable<MmMaterial>()
                        .Where(it => it.ParentMaterialCode == workorderInfo.productionCode)
                        .ToList();
                    foreach (MmMaterial mmMaterial in bomList)
                    {
                        var InventoryList = Context
                            .Queryable<MmInventory>()
                            .Where(it => it.MaterialCode == mmMaterial.MaterialCode)
                            .Where(it => it.SupplierCode == mmMaterial.SupplierCode)
                            .Where(it => it.LocationCode == "YCL001" || it.LocationCode == "CP001")
                            .Where(it => it.CurrentQty > 0)
                            .Select(it => new MaterialInventoryDto
                            {
                                MaterialId = it.Id,
                                MaterialCode = it.MaterialCode,
                                MaterialName = it.MaterialName,
                                CurrentQuantity = it.CurrentQty,
                                SupplierCode = it.SupplierCode,
                                SupplierName = it.SupplierName,
                                Unit = it.Unit,
                                BatchNo = it.BatchNo,
                            })
                            .OrderBy(it => it.MaterialCode)
                            .OrderBy(it => it.BatchNo)
                            .ToList();
                        result.AddRange(InventoryList);
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("查询物料库存失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 工单领料接口
        /// </summary>
        /// <param name="request">领料请求参数</param>
        /// <returns>操作结果</returns>
        public bool TakeMaterial(MaterialTakeRequestDto request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    throw new ArgumentNullException(nameof(request), "领料请求参数不能为空");
                }

                if (string.IsNullOrEmpty(request.Workorder))
                {
                    throw new ArgumentNullException(nameof(request.Workorder), "工单号不能为空");
                }

                if (request.Quantity <= 0)
                {
                    throw new ArgumentException("领料数量必须大于0", nameof(request.Quantity));
                }

                var materialInventory = Context
                    .Queryable<MmInventory>()
                    .First(it => it.Id == request.MaterialInventoryId);
                if (materialInventory == null)
                {
                    throw new ArgumentNullException(
                        nameof(request.MaterialInventoryId),
                        "物料库存ID查询失败"
                    );
                }
                // 业务逻辑实现部分留空待后续补充
                // 此处应实现验证库存是否充足，更新库存数量，记录领料记录
                ReportFlowService _reportFlowService = new ReportFlowService();
                string workorder = request.Workorder;
                string workorderRaw = request.WorkorderRaw;
                int processId = 10;
                int finishNum = (int)request.Quantity;
                string stoveCode = request.StoveCode;
                string feedOrder = materialInventory.BatchNo;
                string worker = request.Operator;
                var result = _reportFlowService.FeedProcessReportwork(
                    workorder,
                    processId,
                    finishNum,
                    stoveCode,
                    feedOrder,
                    worker,
                    workorderRaw,
                    materialInventory.Id
                );
                // 示例返回true
                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("领料操作失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 工单成品入库接口
        /// </summary>
        /// <param name="request">成品入库请求参数</param>
        /// <returns>操作结果</returns>
        public bool StoreProduct(ProductStorageRequestDto request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    throw new ArgumentNullException(nameof(request), "成品入库请求参数不能为空");
                }

                if (string.IsNullOrEmpty(request.Workorder))
                {
                    throw new ArgumentNullException(nameof(request.Workorder), "工单号不能为空");
                }

                if (request.Quantity <= 0)
                {
                    throw new ArgumentException("成品数量必须大于0", nameof(request.Quantity));
                }

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == request.Workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(request.Workorder));
                }
                ReportFlowService _reportFlowService = new ReportFlowService();
                string workorder = request.Workorder;
                int processId = 70;
                int finishNum = (int)request.Quantity;
                int badNum = 0;
                string worker = request.Operator;
                var result = _reportFlowService.ProcessReportWork(
                    workorder,
                    processId,
                    finishNum,
                    badNum,
                    worker
                );
                // 示例返回true
                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("成品入库操作失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 工单出货接口
        /// </summary>
        /// <param name="request">出货请求参数</param>
        /// <returns>操作结果</returns>
        public bool ShipProduct(ShipmentRequestDto request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    throw new ArgumentNullException(nameof(request), "出货请求参数不能为空");
                }

                if (string.IsNullOrEmpty(request.Workorder))
                {
                    throw new ArgumentNullException(nameof(request.Workorder), "工单号不能为空");
                }

                if (string.IsNullOrEmpty(request.OrderId))
                {
                    throw new ArgumentNullException(nameof(request.OrderId), "订单ID不能为空");
                }

                // 业务逻辑实现部分留空待后续补充
                // 此处应实现验证库存是否充足，更新库存状态，记录出货信息
                OrderPurchase orderPurchase = Context
                    .Queryable<OrderPurchase>()
                    .Where(o => o.Id == request.OrderId)
                    .First();

                ReportFlowService _reportFlowService = new ReportFlowService();
                string workorder = request.Workorder;
                int processId = 90;
                int finishNum = (int)request.Quantity;
                int badNum = 0;
                string customerOrder = orderPurchase.OrderNoMes;
                string worker = request.Operator;
                var result = _reportFlowService.ShipmentProcessReportwork(
                    workorder,
                    processId,
                    finishNum,
                    badNum,
                    customerOrder,
                    worker
                );
                return result == 1;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("出货操作失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 根据工单号获取可领料工单清单（产成品领取半成品）
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>可领料工单清单</returns>
        public List<ProWorkorderDto> GetPickableWorkordersByWorkorder(string workorder)
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(workorder))
                {
                    throw new ArgumentNullException(nameof(workorder), "工单号不能为空");
                }

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(workorder));
                }
                // 需要领取半成品
                if (workorderInfo.RouteCode == "10")
                {
                    return Context
                        .Queryable<MmRecordInbound>()
                        .LeftJoin<ProWorkorder>((mri,pro)=>mri.Workorder == pro.Workorder)
                        .Where((mri, pro) => mri.MaterialCode == workorderInfo.MaterialCode)
                        .Where((mri, pro) => mri.TransactionType == "生产入库")
                        .Where((mri, pro) => mri.Remarks != "已撤销")
                        //.Where((mri, pro) => pro.ShipmentNum < pro.PlanNum)
                        .OrderByDescending((mri, pro) => mri.Workorder)
                        .Select(
                            (mri, pro) => new ProWorkorderDto
                            {
                                Id = pro.Id,
                                Workorder = mri.Workorder,
                                productionName = mri.MaterialCode,
                                productionCode = mri.MaterialName,
                                MaterialCode = mri.MaterialCode,
                                MaterialName = mri.MaterialName,
                                ShipmentNum = pro.ShipmentNum ?? 0,
                                PlanNum = pro.PlanNum ?? 0,
                                Remark01 = mri.Remarks
                            },
                            true
                        )
                        .Take(30)
                        .ToList();
                }
                else
                {
                    // 非10线则返回库存

                    // 示例返回空列表
                    return new List<ProWorkorderDto>();
                }
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("获取可领料工单清单失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 根据工单号获取可出货订单清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>可出货订单清单</returns>
        public List<OrderPurchaseDto> GetShippableOrdersByWorkorder(string workorder)
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(workorder))
                {
                    throw new ArgumentNullException(nameof(workorder), "工单号不能为空");
                }

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(workorder));
                }
                var orderPurchaseList = Context
                    .Queryable<OrderPurchase>()
                    .Where(o => o.MaterialCode == workorderInfo.productionCode)
                    .Where(it => it.Orderindicator != 1)
                    //.Where(it => it.Orderindicator != -1)
                    .OrderBy(it => it.DeliveryDate)
                    .Select(
                        o => new OrderPurchaseDto
                        {
                            Id = o.Id,
                            OrderNoMes = o.OrderNoMes,
                            MaterialCode = o.MaterialCode,
                            MaterialName = o.MaterialName,
                            DemandQuantity = o.DemandQuantity,
                            DeliveryQuantity = o.DeliveryQuantity,
                            DeliveryDate = o.DeliveryDate,
                        },
                        true
                    )
                    .ToList();

                // 示例返回空列表
                return orderPurchaseList;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("获取可出货订单清单失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 根据工单号查询成品库存
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>成品库存信息列表</returns>
        public List<MaterialInventoryDto> GetProductInventoryList(string workorder)
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(workorder))
                {
                    throw new ArgumentNullException(nameof(workorder), "工单号不能为空");
                }

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(workorder));
                }
                var result = Context
                    .Queryable<MmInventory>()
                    .Where(it => it.MaterialCode == workorderInfo.productionCode)
                    .Where(it => it.LocationCode == "CP001")
                    //.Where(it => it.CurrentQty > 0)
                    .Select(it => new MaterialInventoryDto
                    {
                        MaterialId = it.Id,
                        MaterialCode = it.MaterialCode,
                        MaterialName = it.MaterialName,
                        CurrentQuantity = it.CurrentQty,
                        SupplierCode = it.SupplierCode,
                        SupplierName = it.SupplierName,
                        Unit = it.Unit,
                        BatchNo = it.BatchNo,
                    })
                    .OrderByDescending(it => it.BatchNo)
                    .Take(10)
                    .ToList();

                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("查询成品库存失败", ex);
                throw;
            }
        }
    }
}