DEMOMySql/MicroServices/Business/Business.Application/ResourceExamineManagement/PurchaseOrderAppService.cs

using Business.Core.Enum;
using Business.Core.Utilities;
using Business.Domain;
using Business.ResourceExamineManagement.Dto;
using Business.StructuredDB.MES;
using System;
using System.Collections.Generic;
using System.Linq;
using Volo.Abp.Application.Services;

namespace Business.ResourceExamineManagement
{
    public class PurchaseOrderAppService : ApplicationService
    {
        #region 服务
        ///// <summary>
        ///// 采购订单
        ///// </summary>
        ////private readonly IMongoDB<mo_srm_po_main> _mo_srm_po_main;
        ///// <summary>
        ///// 采购订单明细详情
        ///// </summary>
        ////private readonly IMongoDB<mo_srm_po_list> _mo_srm_po_list;

        ///// <summary>
        ///// 采购订单占用详情
        ///// </summary>
        ////private readonly IMongoDB<mo_srm_po_occupy> _mo_srm_po_occupy;
        ///// <summary>
        ///// 采购申请单
        ///// </summary>
        ////private readonly IMongoDB<mo_srm_pr_main> _mo_srm_pr_main;

        /// <summary>
        /// 资源检查入参
        /// </summary>
        public SeorderentryDto param = new SeorderentryDto();

        /// <summary>
        ///  雪花算法
        /// </summary>
        SnowFlake snowFlake = new SnowFlake();
        /// <summary>
        /// 采购明细
        /// </summary>
        public List<mo_srm_po_list> mo_Srm_Po_Lists = new List<mo_srm_po_list>();
        /// <summary>
        /// 采购占用
        /// </summary>
        public List<mo_srm_po_occupy> srm_Po_Occupies = new List<mo_srm_po_occupy>();

        /// <summary>
        /// 在途PR
        /// </summary>
        public List<mo_srm_pr_main> srm_Pr_Mains = new List<mo_srm_pr_main>();

        public mes_morder mes_morder = new mes_morder();
        public List<scm_jhjh_jqDto> scm_Jhjh_Jqs = new List<scm_jhjh_jqDto>();
        public List<scm_shdzbDto> scm_Shdzbs = new List<scm_shdzbDto>();
        public List<scm_shdzbDto> scm_ShdzbJYs = new List<scm_shdzbDto>();
        #endregion
        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="icitem"></param>
        /// <param name="icbom"></param>
        public PurchaseOrderAppService(
        //    IMongoDB<mo_srm_po_main> mo_srm_po_main,
        //    IMongoDB<mo_srm_po_list> mo_srm_po_list,
        //    IMongoDB<mo_srm_po_occupy> mo_srm_po_occupy,
        //    IMongoDB<mo_srm_pr_main> mo_srm_pr_main
            )
        {
            //_mo_srm_po_main = mo_srm_po_main;
            //_mo_srm_po_list = mo_srm_po_list;
            //_mo_srm_po_occupy = mo_srm_po_occupy;
            //_mo_srm_pr_main = mo_srm_pr_main;
        }
        #endregion
        /// <summary>
        /// 检查在途订单
        /// </summary>
        public List<mo_srm_po_occupy> CheckPurchaseOrder(crm_seorderentry seorderentry, long icitem_id, decimal Quantity, DateTime DeliverDate, List<mo_ic_item> ic_PlanList, long? supplier_id, long bang_id)
        {
            List<mo_srm_po_occupy> occupyList = new List<mo_srm_po_occupy>();
            List<string> purords = new List<string>();
            var ic_Plan = ic_PlanList.Where(x => x.mysql_id == icitem_id).FirstOrDefault();
            //查询出对应物料采购订单明细  --数据未被停用 && 评审通过后
            List<mo_srm_po_list> poDetailList = new List<mo_srm_po_list>();
            if (supplier_id != null)
            {
                poDetailList = mo_Srm_Po_Lists.Where(x => x.icitem_id == icitem_id && x.pr_purchase_id == supplier_id && x.rarrdate.GetValueOrDefault() < DeliverDate).ToList();
            }
            else
            {
                poDetailList = mo_Srm_Po_Lists.Where(x => x.icitem_id == icitem_id && x.rarrdate.GetValueOrDefault() < DeliverDate).ToList();
            }
            //先查询出满足日期，并且数量可满足占用的数据
            //var poDetails = poDetailList.Where(x => x.rarrdate.GetValueOrDefault() < DeliverDate && x.qty - x.rqty - x.esqty -
            //poOccupys.Where(p => p.polist_id == x.mysql_id)?.Sum(m => m.qty) > Quantity).OrderByDescending(x => x.rarrdate).ToList();
            //日期满足
            /*var backPodtls = poDetailList.Where(x => x.rarrdate.GetValueOrDefault() < DeliverDate).ToList();
            var occpolist = new List<mo_srm_po_occupy>();
            foreach (var pdtl in backPodtls)
            {
                occpolist = poOccupys.Where(p => p.polist_id == pdtl.mysql_id).ToList();
                decimal occqty = 0;
                if (occpolist.Any())
                {
                    occqty = occpolist.Sum(m => m.qty.GetValueOrDefault());
                }
                if (pdtl.qty - pdtl.rqty - pdtl.esqty - occqty > Quantity)
                {
                    poDetails.Add(pdtl);
                }
            }*/
            var QuantityNumber = 0.00m;
            List<mo_srm_po_occupy> poOccupy = new List<mo_srm_po_occupy>();
            foreach (var item in poDetailList)
            {
                poOccupy = srm_Po_Occupies.Where(x => x.polist_id == item.mysql_id).ToList();
                decimal? Qtys = poOccupy.Count > 0 ? poOccupy.Sum(x => x.qty.GetValueOrDefault()) : 0.00m;
                //剩余可用数量
                var PlanQty = item.qty.GetValueOrDefault() - item.rqty.GetValueOrDefault() - item.esqty.GetValueOrDefault() - Qtys;
                if (PlanQty > 0)
                {
                    //可占用数量-需求数量小于0时 占用全部可占用数量
                    if (PlanQty - Quantity <= 0)
                    {
                        QuantityNumber = PlanQty.GetValueOrDefault();
                    }
                    else
                    {
                        //可占用数量满足 需求数量时直接占用需求数量
                        QuantityNumber = Quantity;
                    }
                    var mes_Mooccupy = GetMooccupies(seorderentry, item.mysql_id, item.create_time, item.rarrdate, QuantityNumber, bang_id, 1);
                    purords.Add(item.po_billno);
                    occupyList.Add(mes_Mooccupy);
                    //当剩余需要数量大于0则继续寻找可占用工单，已满足需要数量停止循环查找
                    if (Quantity - PlanQty <= 0)
                    {
                        break;
                    }
                    Quantity = Quantity - PlanQty.GetValueOrDefault();
                }
            }
            //代表PO还未占用完
            if (Quantity > 0)
            {
                var prlist = srm_Pr_Mains.Where(x => x.icitem_id.Value == icitem_id && x.pr_sarrive_date < DeliverDate && x.pr_mono != mes_morder.morder_no).OrderByDescending(f => f.pr_sarrive_date).ToList();
                if (prlist.Any())
                {
                    if (supplier_id != null)
                    {
                        prlist = prlist.Where(x => x.pr_purchaseid == supplier_id).ToList();
                    }
                    if (mes_morder != null)
                    {
                        if (supplier_id != null)
                        {
                            prlist.AddRange(srm_Pr_Mains.Where(x => x.icitem_id.Value == icitem_id && x.pr_purchaseid == supplier_id && x.pr_mono == mes_morder.morder_no).OrderByDescending(f => f.pr_sarrive_date).ToList());
                        }
                        else
                        {
                            prlist.AddRange(srm_Pr_Mains.Where(x => x.icitem_id.Value == icitem_id && x.pr_mono == mes_morder.morder_no).OrderByDescending(f => f.pr_sarrive_date).ToList());
                        }
                    }
                    foreach (var pr in prlist)
                    {
                        decimal prOccupy = srm_Po_Occupies.Where(x => x.polist_id == pr.mysql_id).Sum(c => c.qty.GetValueOrDefault());
                        //剩余可用数量
                        var prQty = pr.pr_aqty - prOccupy;
                        if (prQty > 0)
                        {
                            //可占用数量-需求数量小于0时 占用全部可占用数量
                            if (prQty - Quantity <= 0)
                            {
                                QuantityNumber = prQty.GetValueOrDefault();
                            }
                            else
                            {
                                //可占用数量满足 需求数量时直接占用需求数量
                                QuantityNumber = Quantity;
                            }
                            var mes_Mooccupy = GetMooccupies(seorderentry, pr.mysql_id, pr.create_time, pr.pr_sarrive_date, QuantityNumber, bang_id, 1);
                            occupyList.Add(mes_Mooccupy);
                            //当剩余需要数量大于0则继续寻找可占用，已满足需要数量停止循环查找
                            if (Quantity - prQty <= 0)
                            {
                                break;
                            }
                            Quantity = Quantity - prQty.GetValueOrDefault();
                        }

                    }
                }
            }
            return occupyList.OrderByDescending(s => s.etime).ToList();
        }

        /// <summary>
        /// 检查在途和交期订单
        /// </summary>
        public List<mo_srm_po_occupy> CheckPurchaseOrderORJQ(crm_seorderentry seorderentry, long icitem_id, decimal Quantity, DateTime DeliverDate, List<mo_ic_item> ic_PlanList, long? supplier_id, long bang_id)
        {
            List<mo_srm_po_occupy> occupyList = new List<mo_srm_po_occupy>();
            List<string> purords = new List<string>();
            var ic_Plan = ic_PlanList.Where(x => x.mysql_id == icitem_id).FirstOrDefault();
            //查询出对应物料采购订单明细  --数据未被停用 && 评审通过后
            List<mo_srm_po_list> poDetailList = new List<mo_srm_po_list>();
            if (supplier_id != null)
            {
                poDetailList = mo_Srm_Po_Lists.Where(x => x.icitem_id == icitem_id && x.pr_purchase_id == supplier_id).ToList();
            }
            else
            {
                poDetailList = mo_Srm_Po_Lists.Where(x => x.icitem_id == icitem_id).ToList();
            }
            //送货单
            var shd = scm_Shdzbs.Where(x => x.sh_material_code == ic_Plan.number && x.yjdhrq >= DeliverDate && x.yjdhrq <= DeliverDate.AddDays(5)).ToList();
            if (supplier_id != null)
            {
                shd = shd.Where(x => x.sh_purchase_id == supplier_id).ToList();
            }
            //检验中
            var shdJy = scm_ShdzbJYs.Where(x => x.sh_material_code == ic_Plan.number).ToList();
            if (supplier_id != null)
            {
                shdJy = shdJy.Where(x => x.sh_purchase_id == supplier_id).ToList();
            }
            //承诺交期可用!poDetailList.Select(p => p.po_billno).Contains(x.cgdd)
            var jqs = scm_Jhjh_Jqs.Where(x => ic_Plan.number == x.wlbm && x.jqhf >= DateTime.Today).OrderByDescending(f => f.jqhf).ToList();
            if (supplier_id != null)
            {
                jqs = jqs.Where(x => x.pr_purchase_id == supplier_id).ToList();
            }
            var QuantityNumber = 0.00m;
            List<mo_srm_po_occupy> poOccupy = new List<mo_srm_po_occupy>();
            if (shdJy.Any())
            {
                foreach (var item in shdJy)
                {
                    poOccupy = srm_Po_Occupies.Where(x => x.polist_id == item.polist_id).ToList();
                    decimal? Qtys = poOccupy.Count > 0 ? poOccupy.Sum(x => x.qty.GetValueOrDefault()) : 0.00m;
                    //剩余可用数量
                    var PlanQty = item.sh_delivery_quantity - Qtys;
                    if (PlanQty > 0)
                    {
                        //可占用数量-需求数量小于0时 占用全部可占用数量
                        if (PlanQty - Quantity <= 0)
                        {
                            QuantityNumber = PlanQty.GetValueOrDefault();
                        }
                        else
                        {
                            //可占用数量满足 需求数量时直接占用需求数量
                            QuantityNumber = Quantity;
                        }
                        var mes_Mooccupy = GetMooccupies(seorderentry, item.polist_id, item.jhshrq, item.yjdhrq, QuantityNumber, bang_id, 2);
                        purords.Add(item.po_bill);
                        occupyList.Add(mes_Mooccupy);
                        //当剩余需要数量大于0则继续寻找可占用工单，已满足需要数量停止循环查找
                        if (Quantity - PlanQty <= 0)
                        {
                            Quantity = 0;
                            break;
                        }
                        Quantity = Quantity - PlanQty.GetValueOrDefault();
                    }
                }
            }
            if (Quantity > 0 && shd.Any())
            {
                foreach (var item in shd)
                {
                    poOccupy = srm_Po_Occupies.Where(x => x.polist_id == item.polist_id).ToList();
                    decimal? Qtys = poOccupy.Count > 0 ? poOccupy.Sum(x => x.qty.GetValueOrDefault()) : 0.00m;
                    //剩余可用数量
                    var PlanQty = item.sh_delivery_quantity - Qtys;
                    if (PlanQty > 0)
                    {
                        //可占用数量-需求数量小于0时 占用全部可占用数量
                        if (PlanQty - Quantity <= 0)
                        {
                            QuantityNumber = PlanQty.GetValueOrDefault();
                        }
                        else
                        {
                            //可占用数量满足 需求数量时直接占用需求数量
                            QuantityNumber = Quantity;
                        }
                        var mes_Mooccupy = GetMooccupies(seorderentry, item.polist_id, item.jhshrq, item.yjdhrq, QuantityNumber, bang_id, 1);
                        purords.Add(item.po_bill);
                        occupyList.Add(mes_Mooccupy);
                        //当剩余需要数量大于0则继续寻找可占用工单，已满足需要数量停止循环查找
                        if (Quantity - PlanQty <= 0)
                        {
                            Quantity = 0;
                            break;
                        }
                        Quantity = Quantity - PlanQty.GetValueOrDefault();
                    }
                }
            }
            if (Quantity > 0 && jqs.Any())
            {
                foreach (var jq in jqs)
                {
                    decimal prOccupy = srm_Po_Occupies.Where(x => x.polist_id == jq.polist_id).Sum(c => c.qty.GetValueOrDefault());
                    //剩余可用数量
                    var poDetail = poDetailList.Where(p => p.mysql_id == jq.polist_id).ToList();
                    var PlanQty = 0m;
                    if (poDetail.Any())
                    {
                        PlanQty = poDetail[0].qty.GetValueOrDefault() - poDetail[0].rqty.GetValueOrDefault() - poDetail[0].esqty.GetValueOrDefault();
                    }
                    //订单剩余数减去送货单占用数，等于交期可用数
                    var prQty = PlanQty - prOccupy; //jq.jhdsl - prOccupy;
                    if (prQty >= jq.jhdsl)
                    {
                        prQty = jq.jhdsl.GetValueOrDefault();
                    }
                    if (prQty > 0)
                    {
                        //可占用数量-需求数量小于0时 占用全部可占用数量
                        if (prQty - Quantity <= 0)
                        {
                            QuantityNumber = prQty;
                        }
                        else
                        {
                            //可占用数量满足 需求数量时直接占用需求数量
                            QuantityNumber = Quantity;
                        }
                        var mes_Mooccupy = GetMooccupies(seorderentry, jq.polist_id, jq.jqhf, jq.jqhf, QuantityNumber, bang_id, 3);
                        occupyList.Add(mes_Mooccupy);
                        //当剩余需要数量大于0则继续寻找可占用，已满足需要数量停止循环查找
                        if (Quantity - prQty <= 0)
                        {
                            break;
                        }
                        Quantity = Quantity - prQty;
                    }
                }
            }
            return occupyList.OrderByDescending(s => s.etime).ToList();
        }
        /// <summary>
        /// 拼接PO占用表
        /// </summary>
        /// <param name="seorderentry">销售订单子表</param>
        /// <param name="mysql_ic_item">物料详情表</param>
        /// <param name="item">工单表</param>
        /// <param name="mes_mooccupy">占用工单表</param>
        /// <returns></returns>
        public mo_srm_po_occupy GetMooccupies(crm_seorderentry seorderentry, long id, DateTime? stime, DateTime? etime, decimal? number, long bang_id, int state)
        {
            //生成mo_srm_po_occupy采购占用表数据。 
            mo_srm_po_occupy srm_Po_Occupy = new mo_srm_po_occupy();
            srm_Po_Occupy.GenerateNewId(snowFlake.NextId());
            srm_Po_Occupy.mysql_id = snowFlake.NextId();
            srm_Po_Occupy.bang_id = bang_id;
            srm_Po_Occupy.polist_id = id;
            if (seorderentry != null)
            {
                srm_Po_Occupy.eid = seorderentry.Id;
                srm_Po_Occupy.bill_no = seorderentry.seorder_id;
                srm_Po_Occupy.entry_id = seorderentry.entry_seq.GetValueOrDefault();
                srm_Po_Occupy.org_id = seorderentry.org_id;
            }

            srm_Po_Occupy.qty = number;
            srm_Po_Occupy.type = MorderEnum.Zyjc_Type;//TODO:类型未知
            srm_Po_Occupy.stime = stime;
            srm_Po_Occupy.etime = etime;
            srm_Po_Occupy.state = state;
            srm_Po_Occupy.company_id = param.company_id;//取销售子表企业ID
            srm_Po_Occupy.factory_id = param.factoryId;
            return srm_Po_Occupy;
        }
    }
}