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

using Business.Core.Enum;
using Business.Core.Utilities;
using Business.Domain;
using Business.ResourceExamineManagement.Dto;
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();
        #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>();

            var ic_Plan = ic_PlanList.Where(x => x.mysql_id == icitem_id).FirstOrDefault();
            //查询出对应物料采购订单明细  --数据未被停用 && 评审通过后
            var poDetailList = mo_Srm_Po_Lists.Where(x => x.icitem_id == icitem_id);
            if (supplier_id != null)
            {
                poDetailList = poDetailList.Where(x => x.pr_purchase_id == supplier_id);
            }
            
            //采购订单占用数据
            var poOccupys = srm_Po_Occupies.Where(x => poDetailList.Select(p => p.mysql_id).ToList().Contains(x.polist_id));

            DateTime toTime = DateTime.Now.Date;

            //先查询出满足日期，并且数量可满足占用的数据
            //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();
            List<mo_srm_po_list> poDetails = new List<mo_srm_po_list>();
            //日期满足
            /*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);
                }
            }*/
            //未满足则查询出满足日期的订单
            if (poDetails.Count == 0)
            {
                poDetails = poDetailList.Where(x => x.rarrdate.GetValueOrDefault() < DeliverDate).OrderByDescending(x => x.rarrdate).ToList();
            }
            else
            {
                poDetails = poDetails.OrderByDescending(x => x.rarrdate).ToList();
            }
            var QuantityNumber = 0.00m;
            List<mo_srm_po_occupy> poOccupy = new List<mo_srm_po_occupy>();
            foreach (var item in poDetails)
            {
                poOccupy = poOccupys.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);
                    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 (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);
                        occupyList.Add(mes_Mooccupy);
                        //当剩余需要数量大于0则继续寻找可占用，已满足需要数量停止循环查找
                        if (Quantity - prQty <= 0)
                        {
                            break;
                        }
                        Quantity = Quantity - prQty.GetValueOrDefault();
                    }

                }
            }
            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)
        {
            //生成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 = 1;
            srm_Po_Occupy.company_id = param.company_id;//取销售子表企业ID
            srm_Po_Occupy.factory_id = param.factoryId;
            return srm_Po_Occupy;
        }
    }
}