DEMOMySql/MicroServices/Business/Business.Application/ReplenishmentManagement/ReplenishmentAppService.cs

using Business.Core.Enum;
using Business.Core.Utilities;
using Business.Domain;
using Business.Dto;
using Business.EntityFrameworkCore;
using Business.EntityFrameworkCore.SqlRepositories;
using Business.ReplenishmentManagement;
using Business.ResourceExamineManagement;
using Business.ResourceExamineManagement.Dto;
using Business.StructuredDB.Replenishment;
using Business.StructuredDB.SaleFcst;
using Business.StructuredDB.WMS;
using EFCore.BulkExtensions;
using Microsoft.EntityFrameworkCore;
using MongoDB.Driver;
using MongoDB.Driver.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.MultiTenancy;
using Volo.Abp.Uow;

namespace Business.Replenishment
{
    /// <summary>
    /// 产能分析
    /// </summary>
    public class ReplenishmentAppService : ApplicationService, IReplenishmentAppService, ITransientDependency
    {
        #region 服务
        /// <summary>
        /// 雪花算法
        /// </summary>
        SnowFlake help = new SnowFlake();
        private readonly IRepository<ReplenishmentROPWeekPlan, long> _replenishmentROPWeekPlan;
        private readonly ISqlRepository<ASNBOLShipperDetail> _ASNBOLShipperDetail;
        private readonly ISqlRepository<ASNBOLShipperMaster> _ASNBOLShipperMaster;
        private readonly ISqlRepository<InvTransHist> _invTransHist;
        private readonly ISqlRepository<InvMaster> _invMaster;
        private readonly IRepository<srm_purchase, long> _srmPurchase;
        private readonly ISqlRepository<MonthlyShipmentPlan> _monthlyShipmentPlan;
        private readonly ISqlRepository<GeneralizedCodeMaster> _generalizedCodeMaster;
        private readonly IRepository<mo_ic_item, long> _ic_item;
        private readonly IRepository<ic_item, long> _mysql_ic_item;
        private readonly ISqlRepository<ItemMaster> _itemMaster;
        private readonly IRepository<mo_srm_pr_main, long> _srm_pr_main;
        private readonly IRepository<srm_pr_main, long> _mysql_srm_pr_main;
        private readonly IRepository<mo_srm_po_occupy, long> _srm_po_occupy;
        private readonly IRepository<srm_po_occupy, long> _mysql_srm_po_occupy;
        private readonly IRepository<srm_pr_main_occupy, long> _mysql_srm_pr_main_occupy;
        private readonly IRepository<mo_mes_morder, long> _mes_morder;
        private readonly IRepository<mo_mes_moentry, long> _mes_moentry;
        private readonly IRepository<mo_mes_mooccupy, long> _mes_mooccupy;
        private readonly IRepository<mes_mooccupy, long> _mysql_mes_mooccupy;
        private readonly IRepository<b_bom_pretreatment, long> _mysql_b_bom_pretreatment;
        private readonly ISqlRepository<WorkOrdMaster> _workOrdMaster;
        private readonly ISqlRepository<ProdLineDetail> _prodLineDetail;
        private readonly ISqlRepository<LineMaster> _lineMaster;
        private readonly IRepository<mo_ic_bom, long> _ic_bom;
        private readonly IRepository<ic_bom, long> _mysql_ic_bom;
        private readonly IRepository<mo_ic_bom_child, long> _ic_bom_child;
        private readonly IRepository<ic_bom_child, long> _mysql_ic_bom_child;
        private readonly ISqlRepository<HolidayMaster> _holidayMaster;
        private readonly IRepository<mo_ic_item_stockoccupy, long> _ic_item_stockoccupy;
        private readonly IRepository<ic_item_stockoccupy, long> _mysql_ic_item_stockoccupy;
        private readonly IRepository<mo_ic_item_stock, long> _ic_item_stock;
        private readonly IRepository<ic_item_stock, long> _mysql_ic_item_stock;
        private readonly IRepository<mo_ic_substitute, long> _ic_substitute;
        private readonly IRepository<mo_ic_substitute_group, long> _ic_substitute_group;
        private readonly IRepository<mo_ic_substitute_group_detail, long> _ic_substitute_group_detail;
        private readonly IRepository<ic_substitute, long> _mysql_ic_substitute;
        private readonly IRepository<ic_substitute_group, long> _mysql_ic_substitute_group;
        private readonly IRepository<ic_substitute_group_detail, long> _mysql_ic_substitute_group_detail;
        private readonly IRepository<mes_moentry, long> _mysql_mes_moentry;
        private readonly ISqlRepository<WorkOrdDetail> _workOrdDetail;
        private readonly IRepository<mo_srm_po_list, long> _srm_po_list;
        private readonly IRepository<srm_po_list, long> _mysql_srm_po_list;
        private readonly ISqlRepository<RoutingOpDetail> _routingOpDetail;
        private readonly ISqlRepository<ProductStructureMaster> _productStructureMaster;
        private readonly ISqlRepository<ShopCalendarWorkCtr> _shopCalendarWorkCtr;
        private readonly ISqlRepository<PeriodSequenceDet> _periodSequenceDet;
        private readonly ISqlRepository<QualityLineWorkDetail> _qualityLineWorkDetail;
        private readonly ISqlRepository<CustMaster> _custMaster;
        private readonly IRepository<mo_srm_po_main, long> _srm_po_main;
        private readonly IRepository<srm_po_main, long> _mysql_srm_po_main;
        private readonly IRepository<mo_srm_purchase, long> _srm_purchase;
        private readonly IRepository<srm_purchase, long> _mysql_srm_purchase;
        private readonly IRepository<mes_morder, long> _mysql_mes_morder;
        private readonly IRepository<crm_seorder, long> _mysql_crm_seorder;
        private readonly IRepository<crm_seorderentry, long> _mysql_crm_seorderentry;
        private readonly IRepository<ProductionMasterPlan, long> _productionMasterPlan;
        private readonly IRepository<ReplenishmentWeekPlan, long> _replenishmentWeekPlan;
        private readonly IRepository<b_examine_result, long> _mysql_examine_result;
        private readonly IRepository<b_bom_child_examine, long> _mysql_bom_child_examine;
        private readonly IRepository<ReplenishmentServiceLevel, long> _replenishmentServiceLevel;
        private readonly IExtSqlRepository<DMS_IN_ITEMMAPPING> _DMS_IN_ITEMMAPPING;
        private readonly IExtSqlRepository<DMS_IN_LOCDETAIL> _DMS_IN_LOCDETAIL;
        private readonly IExtSqlRepository<DMS_IN_PODETAIL> _DMS_IN_PODETAIL;
        private readonly IExtSqlRepository<DMS_IN_RETAILER> _DMS_IN_RETAILER;
        private readonly IExtSqlRepository<DMS_IN_SHIPPINGDETAIL> _DMS_IN_SHIPPINGDETAIL;
        private readonly IRepository<ReplenishmentTurnOverSet> _ReplenishmentTurnOverSet;

        /// <summary>
        /// 年度销售预测
        /// </summary>
        private IRepository<YearDemandManagement, long> _yearDemandManagement;

        /// <summary>
        /// 年度销售预测历史记录
        /// </summary>
        private IRepository<YearDemandManagementHistory, long> _yearDemandManagementHistory;

        /// <summary>
        /// 年度生产大纲
        /// </summary>
        private IRepository<ReplenishmentAnnualProduction, long> _replenishmentAnnualProduction;


        /// <summary>
        /// 平台库存表
        /// </summary>
        private readonly IRepository<WMS_PlatformInventory, long> _PlatformInventory;

        /// <summary>
        /// 工单工艺路线明细
        /// </summary>
        private ISqlRepository<WorkOrdRouting> _workOrdRouting;






        /// <summary>
        /// 月度产能共识表
        /// </summary>
        private IRepository<MonthlyProdCapacity, long> _monthlyProdCapacity;

        /// <summary>
        /// 月度产能共识明细表
        /// </summary>
        private IRepository<MonthlyProdCapacityDtl, long> _monthlyProdCapacityDtl;
        /// <summary>
        /// 计划订单表
        /// </summary>
        private IRepository<crm_planorder, long> _crm_planorder;


        /// <summary>
        /// 平台库存表
        /// </summary>
        private IRepository<WMS_PlatformInventory, long> _platformInventory;




        /// <summary>
        /// 在途检查
        /// </summary>
        private readonly PurchaseOrderAppService _purchaseOrderAppService;
        /// <summary>
        /// 计算BOM平铺物料情况
        /// </summary>
        private readonly CalcBomViewAppService _CalcBomViewAppService;

        /// <summary>
        /// 预处理
        /// </summary>
        private readonly PretreatmentAppService _pretreatmentAppService;

        private readonly SerialNumberAppService _serialNumberAppService;

        /// <summary>
        /// 产能检查
        /// </summary>
        private readonly ProductExamineAppService _productExamineAppService;

        /// <summary>
        /// 资源检查入参
        /// </summary>
        private readonly SeorderentryDto param = new SeorderentryDto();
        /// <summary>
        /// 生产线明细表
        /// </summary>
        public List<ProdLineDetail> prodLines = new List<ProdLineDetail>();

        /// <summary>
        /// 标准工艺路径表
        /// </summary>
        public List<RoutingOpDetail> routingOps = new List<RoutingOpDetail>();

        /// <summary>
        /// 排产记录表
        /// </summary>
        public List<PeriodSequenceDet> periodSequences = new List<PeriodSequenceDet>();

        /// <summary>
        /// 工作日历
        /// </summary>
        public List<ShopCalendarWorkCtr> calendarWorks = new List<ShopCalendarWorkCtr>();

        /// <summary>
        /// 休息时间段
        /// </summary>
        public List<QualityLineWorkDetail> qualityLineWorks = new List<QualityLineWorkDetail>();

        /// <summary>
        /// 节假日
        /// </summary>
        public List<HolidayMaster> holidays = new List<HolidayMaster>();
        private List<ICItemLeadTimeDto> leadTimeList;
        private List<mo_srm_purchase> supplierList;
        private readonly BusinessBangDbContext _businessBangDbContext;
        private readonly BusinessDbContext _businessDbContext;
        private readonly ICurrentTenant _currentTenant;
        private readonly IUnitOfWorkManager _unitOfWorkManager;
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public ReplenishmentAppService(
            IRepository<ReplenishmentROPWeekPlan, long> replenishmentROPWeekPlan,
            ISqlRepository<ASNBOLShipperDetail> ASNBOLShipperDetail,
            ISqlRepository<ASNBOLShipperMaster> ASNBOLShipperMaster,
            ISqlRepository<InvTransHist> invTransHist,
            IRepository<srm_purchase, long> srmPurchase,
            ISqlRepository<MonthlyShipmentPlan> monthlyShipmentPlan,
            ISqlRepository<GeneralizedCodeMaster> generalizedCodeMaster,
            ISqlRepository<InvMaster> invMaster,
            IRepository<mo_ic_item, long> ic_item,
            IRepository<ic_item, long> mysql_ic_item,
            ISqlRepository<ItemMaster> itemMaster,
            IRepository<mo_srm_pr_main, long> srm_pr_main,
            IRepository<srm_pr_main, long> mysql_srm_pr_main,
            IRepository<mo_srm_po_occupy, long> srm_po_occupy,
            IRepository<srm_po_occupy, long> mysql_srm_po_occupy,
            IRepository<srm_pr_main_occupy, long> mysql_srm_pr_main_occupy,
            IRepository<mo_mes_morder, long> mes_morder,
            IRepository<mo_mes_moentry, long> mes_moentry,
            IRepository<mo_mes_mooccupy, long> mes_mooccupy,
            IRepository<mes_mooccupy, long> mysql_mes_mooccupy,
            IRepository<b_bom_pretreatment, long> mysql_b_bom_pretreatment,
            ISqlRepository<WorkOrdMaster> workOrdMaster,
            ISqlRepository<ProdLineDetail> prodLineDetail,
            ISqlRepository<LineMaster> lineMaster,
            IRepository<mo_ic_bom, long> ic_bom,
            IRepository<ic_bom, long> mysql_ic_bom,
            IRepository<mo_ic_bom_child, long> ic_bom_child,
            IRepository<ic_bom_child, long> mysql_ic_bom_child,
            ISqlRepository<HolidayMaster> holidayMaster,
            IRepository<mo_ic_item_stockoccupy, long> ic_item_stockoccupy,
            IRepository<ic_item_stockoccupy, long> mysql_ic_item_stockoccupy,
            IRepository<mo_ic_item_stock, long> ic_item_stock,
            IRepository<ic_item_stock, long> mysql_ic_item_stock,
            IRepository<mo_ic_substitute, long> ic_substitute,
            IRepository<mo_ic_substitute_group, long> ic_substitute_group,
            IRepository<mo_ic_substitute_group_detail, long> ic_substitute_group_detail,
            IRepository<ic_substitute, long> mysql_ic_substitute,
            IRepository<ic_substitute_group, long> mysql_ic_substitute_group,
            IRepository<ic_substitute_group_detail, long> mysql_ic_substitute_group_detail,
            IRepository<mes_moentry, long> mysql_mes_moentry,
            ISqlRepository<WorkOrdDetail> workOrdDetail,
            IRepository<mo_srm_po_list, long> srm_po_list,
            IRepository<srm_po_list, long> mysql_srm_po_list,
            ISqlRepository<RoutingOpDetail> routingOpDetail,
            ISqlRepository<ProductStructureMaster> productStructureMaster,
            ISqlRepository<ShopCalendarWorkCtr> shopCalendarWorkCtr,
            ISqlRepository<PeriodSequenceDet> periodSequenceDet,
            ISqlRepository<QualityLineWorkDetail> qualityLineWorkDetail,
            IRepository<mo_srm_po_main, long> srm_po_main,
            IRepository<srm_po_main, long> mysql_srm_po_main,
            IRepository<mo_srm_purchase, long> srm_purchase,
            IRepository<srm_purchase, long> mysql_srm_purchase,
            IRepository<mes_morder, long> mysql_mes_morder,
            IRepository<crm_seorder, long> mysql_crm_seorder,
            IRepository<crm_seorderentry, long> mysql_crm_seorderentry,
            IRepository<mo_mes_oorder, long> mes_oorder,
            ISqlRepository<ScheduleResultOpMaster> scheduleResultOpMaster,
            IRepository<ProductionMasterPlan, long> productionMasterPlan,

            IRepository<YearDemandManagement, long> yearDemandManagement,
            IRepository<ReplenishmentAnnualProduction, long> replenishmentAnnualProduction,
            IRepository<YearDemandManagementHistory, long> yearDemandManagementHistory,
            IRepository<WMS_PlatformInventory, long> PlatformInventory,
            ISqlRepository<WorkOrdRouting> workOrdRouting,
            ISqlRepository<CustMaster> custMaster,
            IRepository<MonthlyProdCapacity, long> monthlyProdCapacity,
            IRepository<MonthlyProdCapacityDtl, long> monthlyProdCapacityDtl,
            IRepository<crm_planorder, long> crm_planorder,
            IRepository<WMS_PlatformInventory, long> platformInventory,
            IRepository<ReplenishmentWeekPlan, long> replenishmentWeekPlan,
            IRepository<b_examine_result, long> mysql_examine_result,
            IRepository<b_bom_child_examine, long> mysql_bom_child_examine,
            IRepository<ReplenishmentServiceLevel, long> replenishmentServiceLevel,

            IExtSqlRepository<DMS_IN_ITEMMAPPING> DMS_IN_ITEMMAPPING,
            IExtSqlRepository<DMS_IN_LOCDETAIL> DMS_IN_LOCDETAIL,
            IExtSqlRepository<DMS_IN_PODETAIL> DMS_IN_PODETAIL,
            IExtSqlRepository<DMS_IN_RETAILER> DMS_IN_RETAILER,
            IExtSqlRepository<DMS_IN_SHIPPINGDETAIL> DMS_IN_SHIPPINGDETAIL,
            IRepository<ReplenishmentTurnOverSet> ReplenishmentTurnOverSet,

            SerialNumberAppService serialNumberAppService,
            PretreatmentAppService pretreatmentAppService,
            PurchaseOrderAppService purchaseOrderAppService,
            CalcBomViewAppService CalcBomViewAppService,
            ProductExamineAppService productExamineAppService,
            BusinessBangDbContext businessBangDbContext,
            BusinessDbContext businessDbContext,
            ICurrentTenant currentTenant,
            IUnitOfWorkManager unitOfWorkManager)
        {
            _replenishmentROPWeekPlan = replenishmentROPWeekPlan;
            _ASNBOLShipperDetail = ASNBOLShipperDetail;
            _ASNBOLShipperMaster = ASNBOLShipperMaster;
            _invTransHist = invTransHist;
            _srmPurchase = srmPurchase;
            _monthlyShipmentPlan = monthlyShipmentPlan;
            _generalizedCodeMaster = generalizedCodeMaster;
            _invMaster = invMaster;
            _ic_item = ic_item;
            _mysql_ic_item = mysql_ic_item;
            _itemMaster = itemMaster;
            _srm_pr_main= srm_pr_main;
            _mysql_srm_pr_main= mysql_srm_pr_main;
            _srm_po_occupy = srm_po_occupy;
            _mysql_srm_po_occupy = mysql_srm_po_occupy;
            _mysql_srm_pr_main_occupy = mysql_srm_pr_main_occupy;
            _mes_morder = mes_morder;
            _mes_moentry = mes_moentry;
            _mes_mooccupy = mes_mooccupy;
            _mysql_mes_mooccupy = mysql_mes_mooccupy;
            _mysql_b_bom_pretreatment = mysql_b_bom_pretreatment;
            _workOrdMaster = workOrdMaster;
            _custMaster=custMaster;
            _prodLineDetail = prodLineDetail;
            _lineMaster= lineMaster;
            _ic_bom = ic_bom;
            _mysql_ic_bom = mysql_ic_bom;
            _ic_bom_child = ic_bom_child;
            _mysql_ic_bom_child = mysql_ic_bom_child;
            _holidayMaster = holidayMaster;
            _ic_item_stockoccupy = ic_item_stockoccupy;
            _mysql_ic_item_stockoccupy = mysql_ic_item_stockoccupy;
            _ic_item_stock = ic_item_stock;
            _mysql_ic_item_stock = mysql_ic_item_stock;
            _ic_substitute = ic_substitute;
            _ic_substitute_group= ic_substitute_group;
            _ic_substitute_group_detail= ic_substitute_group_detail;
            _mysql_ic_substitute= mysql_ic_substitute;
            _mysql_ic_substitute_group= mysql_ic_substitute_group;
            _mysql_ic_substitute_group_detail= mysql_ic_substitute_group_detail;
            _mysql_mes_moentry = mysql_mes_moentry;
            _workOrdDetail = workOrdDetail;
            _srm_po_list = srm_po_list;
            _mysql_srm_po_list = mysql_srm_po_list;
            _routingOpDetail = routingOpDetail;
            _productStructureMaster = productStructureMaster;
            _shopCalendarWorkCtr=shopCalendarWorkCtr;
            _periodSequenceDet = periodSequenceDet;
            _qualityLineWorkDetail= qualityLineWorkDetail;
            _srm_po_main= srm_po_main;
            _mysql_srm_po_main= mysql_srm_po_main;
            _srm_purchase= srm_purchase;
            _mysql_srm_purchase = mysql_srm_purchase;
            _mysql_mes_morder = mysql_mes_morder;
            _mysql_crm_seorder = mysql_crm_seorder;
            _mysql_crm_seorderentry = mysql_crm_seorderentry;
            _productionMasterPlan=productionMasterPlan;
            _replenishmentWeekPlan=replenishmentWeekPlan;
            _mysql_examine_result = mysql_examine_result;
            _mysql_bom_child_examine= mysql_bom_child_examine;
            _replenishmentServiceLevel = replenishmentServiceLevel;

            _PlatformInventory = PlatformInventory;
            _workOrdRouting = workOrdRouting;
            _ASNBOLShipperDetail = ASNBOLShipperDetail;
            _yearDemandManagement = yearDemandManagement;
            _yearDemandManagementHistory = yearDemandManagementHistory;
            _replenishmentAnnualProduction = replenishmentAnnualProduction;
            _holidayMaster = holidayMaster;
            _monthlyProdCapacity = monthlyProdCapacity;
            _monthlyProdCapacityDtl = monthlyProdCapacityDtl;
            _crm_planorder = crm_planorder;
            _platformInventory = platformInventory;

            _DMS_IN_ITEMMAPPING = DMS_IN_ITEMMAPPING;
            _DMS_IN_LOCDETAIL = DMS_IN_LOCDETAIL;
            _DMS_IN_PODETAIL = DMS_IN_PODETAIL;
            _DMS_IN_RETAILER = DMS_IN_RETAILER;
            _DMS_IN_SHIPPINGDETAIL = DMS_IN_SHIPPINGDETAIL;
            _ReplenishmentTurnOverSet= ReplenishmentTurnOverSet;

            _serialNumberAppService= serialNumberAppService;
            _pretreatmentAppService = pretreatmentAppService;
            _CalcBomViewAppService = CalcBomViewAppService;
            _purchaseOrderAppService = purchaseOrderAppService;
            _productExamineAppService = productExamineAppService;
            _currentTenant =currentTenant;
            _businessBangDbContext= businessBangDbContext;
            _businessDbContext = businessDbContext;
            _unitOfWorkManager = unitOfWorkManager;
        }
        #endregion


        /// <summary>
        /// 生成年度生产大纲
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<string> SaveAnnualProductionOutline(InputDto input)
        {
            input.year = DateTime.Now.Year;
            input.month = DateTime.Now.Month;
            //获取当前导入或修改数据
            List<YearDemandManagement> yearDemands = _yearDemandManagement.GetListAsync(p => p.Year == input.year && p.factory_id == input.factory_id && !p.IsDeleted).Result.OrderBy(p => p.OrderNum).ThenBy(o => o.PlanMonth).ToList();
            //标准工艺路径表
            var sapItemList = yearDemands.Select(m => m.SAPItemNumber).Distinct().ToList();
            List<RoutingOpDetail> routingOps = _routingOpDetail.Select(p => sapItemList.Contains(p.RoutingCode) && p.Domain == input.factory_id.ToString() && p.IsActive);
            var routingOpList = routingOps.Where(x => x.Ufld1 == "组装" && x.MilestoneOp).ToList();
            //生产线明细表
            List<ProdLineDetail> prodLines = _prodLineDetail.Select(p => sapItemList.Contains(p.Part) && p.Domain == input.factory_id.ToString() && p.IsActive && routingOpList.Select(m => m.Op).Contains(p.Op)).OrderBy(x => x.Sequence).ToList();
            List<LineMaster> lineMasters = _lineMaster.Select(p => prodLines.Select(a=>a.Line).Distinct().ToList().Contains(p.Line) && p.Domain == input.factory_id.ToString() && p.IsActive).ToList();
            List<InvMaster> locations = _invMaster.Select(x => sapItemList.Contains(x.ItemNum) && x.Domain == input.factory_id.ToString() && x.IsActive).ToList();
            //平台库存
            var DMSItemList = _DMS_IN_ITEMMAPPING.Select(a => sapItemList.Contains(a.CfnERPCode));
            var gkhwStock = _DMS_IN_LOCDETAIL.Select(a => (a.DealerCode == "RQ000005" || a.DealerCode == "RQ000002"));

            var platformInvList = _PlatformInventory.GetListAsync(a => sapItemList.Contains(a.SAPItemNumber) && a.factory_id == input.factory_id && !a.IsDeleted).Result;
            // 获取某年某月的起始日期和结束日期
            int year = input.year;
            int month = DateTime.Now.Month;
            DateTime start = new DateTime(year, month, 1);
            DateTime end = start.AddMonths(1).AddDays(-1);
            //取当月发货出库记录
            var shipList = _ASNBOLShipperDetail.Select(a => a.Domain == input.factory_id.ToString() && a.IsActive && a.shtype == "SH" && a.Typed != "S" && a.RealQty > 0 && yearDemands.Select(p => p.SAPItemNumber).Contains(a.ContainerItem)).Where(s => s.ShipDate >= start && s.ShipDate <= end);
            #region 在制数量
            //获取在制数量 获取工单数取每年4月到12月底的工单
            DateTime startYear = new DateTime(year, 4, 1);
            DateTime endYear = new DateTime(year, 12, 31);
            List<WorkOrdRouting> workOrdRoutings = _workOrdRouting.Select(x => x.IsActive && x.QtyComplete > 0 && x.Domain == input.factory_id.ToString()).Where(p => p.DueDate >= startYear && p.DueDate <= endYear).ToList();
            decimal? InProductionQty = 0.00m;
            var workOrds = workOrdRoutings.GroupBy(x => x.WorkOrd).ToList();
            Dictionary<string, decimal> dictInProduction = new Dictionary<string, decimal>();
            //按照工单循环
            //某工单10-90工序   Max（10-80工序QtyComplete）-90工序QtyComplete =在制数量
            foreach (var item in workOrds)
            {
                var workOrdRoutingList = workOrdRoutings.Where(x => x.WorkOrd == item.Key).OrderByDescending(o => o.OP).ToList();
                //找出最大工序
                var MaxOp = workOrdRoutingList.FirstOrDefault();
                //查询出其他工序最大值
                var MaxQtyComplete = workOrdRoutingList.Where(x => x.RecID != MaxOp.RecID).ToList().Max(o => o.QtyComplete);
                InProductionQty += MaxQtyComplete - MaxOp.QtyComplete;
                if (dictInProduction.ContainsKey(MaxOp.ItemNum))
                {
                    dictInProduction[MaxOp.ItemNum] += InProductionQty.Value;
                }
                else
                {
                    dictInProduction.Add(MaxOp.ItemNum, InProductionQty.Value);
                }
            }
            #endregion
            //年度生产大纲实体
            List<ReplenishmentAnnualProduction> annualProductionOutlines = new List<ReplenishmentAnnualProduction>();
            List<YearDemandManagement> frontYearDemand = new List<YearDemandManagement>();
            foreach (var item in yearDemands)
            {
                var routingOp = routingOps.Where(x => x.RoutingCode == item.SAPItemNumber).ToList();
                //组装标准工时
                var Assembly = routingOp.Where(x => x.Ufld1 == "组装" && x.MilestoneOp).FirstOrDefault();
                //热封标准工时
                var HeatSealing = routingOp.Where(x => x.Ufld1 == "热封" && x.MilestoneOp).FirstOrDefault();
                //包装标准工时
                var Packaging = routingOp.Where(x => x.Ufld1 == "包装" && x.MilestoneOp).FirstOrDefault();
                var prodLine = prodLines.Where(x => x.Part == item.SAPItemNumber).OrderBy(x => x.Sequence).FirstOrDefault();
                //不同库位库存数量
                //5008成品线边库,8001成品合格库,8000成品待检
                var locationList = locations.Where(x => x.ItemNum == item.SAPItemNumber && (x.Location=="5008" || x.Location=="8000" || x.Location=="8001")).ToList();
                //平台数据
                decimal? hwStock = 0;
                if (DMSItemList.Find(d => d.CfnERPCode == item.SAPItemNumber) != null)
                {
                    var itemDMS = gkhwStock.Where(o => o.UPN == DMSItemList.Find(d => d.CfnERPCode == item.SAPItemNumber).CfnCode && o.DealerCode == "RQ000002").ToList();
                    if (itemDMS.Count > 0)
                    {
                        var maxDate = itemDMS.OrderByDescending(i => i.InventoryDate).First();
                        hwStock = itemDMS.Where(i => i.InventoryDate == maxDate.InventoryDate).Sum(q => q.Qty);
                    }
                }
                decimal? gkStock = 0;
                if (DMSItemList.Find(d => d.CfnERPCode == item.SAPItemNumber) != null)
                {
                    var itemDMS = gkhwStock.Where(o => o.UPN == DMSItemList.Find(d => d.CfnERPCode == item.SAPItemNumber).CfnCode && o.DealerCode == "RQ000005").ToList();
                    if (itemDMS.Count > 0)
                    {
                        var maxDate = itemDMS.OrderByDescending(i => i.InventoryDate).First();
                        gkStock = itemDMS.Where(i => i.InventoryDate == maxDate.InventoryDate).Sum(q => q.Qty);
                    }
                }
                //销售预测 对应 Excel中公式 AVERAGE 如果预测为0不参与计算排产批量
                var QtySum = yearDemands.Where(x => x.SAPItemNumber == item.SAPItemNumber && x.Qty > 0).ToList();
                //排产批量：(AVG（1 - 12月销售预测）/ 100 )=（0.45 = 1 小数向上取整）  *100 = 100
                decimal pcpl = 0;
                if (QtySum!=null && QtySum.Count>0)
                {
                    pcpl = Math.Ceiling(QtySum.Average(p => p.Qty) / 100) * 100;
                }
                //库存合计 + 在制+已发货 + 灭菌中 TODO: 灭菌中取值待确定
                var ship = shipList.Where(x => x.ContainerItem == item.SAPItemNumber).ToList();
                decimal itemInProduct = 0;
                if(dictInProduction.ContainsKey(item.SAPItemNumber))
                {
                    itemInProduct = dictInProduction[item.SAPItemNumber];
                }
                var locationSum = (locationList.Count == 0 ? 0 : locationList.Sum(x => x.AvailStatusQty.GetValueOrDefault() + x.Assay.GetValueOrDefault())) + gkStock+ hwStock + (ship.Count == 0 ? 0 : ship.Sum(x => x.RealQty)) + itemInProduct + 0;
                //前面N个月的生产数量
                var frontQtySum = annualProductionOutlines.Sum(x => x.Qty);
                //生产数量：3月为例子，if(（库存合计和前2月生产数量）-（前2个月销售预测数据）-当月销售预测数据 / 2 < 0)
                // { 排产批量 * ((-(库存合计+前12个月生产数量)) +  (前12个月销售预测) + 当月销售预测 / 2 ) / 排产批量 ) } else {0}
                decimal ProduceQty = 0.00m;
                //判断库存是否满足需要，满足则不用生产
                var num = (locationSum.Value + frontQtySum) - frontYearDemand.Sum(m => m.Qty) + 0 - item.Qty / 2;
                if (num < 0||pcpl!=0)
                {
                    ProduceQty = pcpl * Math.Ceiling((-(locationSum.Value + frontQtySum) + (frontYearDemand.Sum(m => m.Qty) + 0) + item.Qty / 2)/ pcpl);
                }
                else
                {
                    ProduceQty = 0;
                }
                if (ProduceQty < 0)
                    ProduceQty = 0;

                //生成年度生产大纲
                ReplenishmentAnnualProduction annualProductionOutline = new ReplenishmentAnnualProduction();
                annualProductionOutline.Year = item.Year;
                annualProductionOutline.Area = item.Area;
                annualProductionOutline.ProdLine = item.ProdLine;
                annualProductionOutline.ProdRange = item.ProdRange;
                if(prodLine == null)
                {
                    annualProductionOutline.WorkshopLine ="";
                }
                else
                {
                    annualProductionOutline.WorkshopLine = lineMasters.Find(b => b.Line == prodLine.Line).Describe;
                }
                
                annualProductionOutline.SAPItemNumber = item.SAPItemNumber;
                annualProductionOutline.Model = item.Model;
                annualProductionOutline.Languages = item.Languages;
                annualProductionOutline.PlanMonth = item.PlanMonth;
                annualProductionOutline.Qty = ProduceQty;
                annualProductionOutline.StandardHours = (Assembly == null ? 0 : Assembly.RunTime) + (HeatSealing == null ? 0 : HeatSealing.RunTime) + (Packaging == null ? 0 : Packaging.RunTime);
                //组装热封包装工时乘以数量 =单月工时
                annualProductionOutline.AssemblyHours = Assembly == null ? 0 : Assembly.RunTime * ProduceQty;
                annualProductionOutline.HeatSealingHours = HeatSealing == null ? 0 : HeatSealing.RunTime * ProduceQty;
                annualProductionOutline.PackagingHours = Packaging == null ? 0 : Packaging.RunTime * ProduceQty;
                annualProductionOutline.Totalhours = annualProductionOutline.AssemblyHours + annualProductionOutline.HeatSealingHours + annualProductionOutline.Totalhours;
                annualProductionOutline.OrderNum = item.OrderNum;
                annualProductionOutline.create_time= DateTime.Now;
                annualProductionOutline.tenant_id = input.tenant_id;
                annualProductionOutline.company_id= input.company_id;
                annualProductionOutline.factory_id= input.factory_id;
                annualProductionOutline.org_id= input.org_id;
                annualProductionOutlines.Add(annualProductionOutline);
                frontYearDemand.Add(item);
            }
            //保存数据
            using (var unitOfWork = _unitOfWorkManager.Begin(false, true))
            {
                try
                {
                    await _replenishmentAnnualProduction.HardDeleteAsync(a => a.Year == input.year && a.factory_id == input.factory_id);
                    await _replenishmentAnnualProduction.InsertManyAsync(annualProductionOutlines);
                    await CalcLongPeriodItemPR(input);
                    await CalcROP(input);
                    await SaveProductionMasterPlan(input, annualProductionOutlines);
                    await unitOfWork.CompleteAsync();
                }
                catch (Exception e)
                {
                    unitOfWork.Dispose();
                    new NLogHelper("AnnualProductionOutlineAppService").WriteLog("SaveAnnualProductionOutline", "【" + input.year + "年" + "】年度生成大纲生成失败：" + e.Message, _currentTenant.Id.ToString());
                    return "NO|" + e.Message;
                };
            }
            return "OK";
        }

        /// <summary>
        /// 生成主计划
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> SaveProductionMasterPlan(InputDto input,List<ReplenishmentAnnualProduction> annual)
        {
            input.year = DateTime.Now.Year;
            input.month = DateTime.Now.Month;
            //计算当前年月的N0,N+1,N+2
            List<string> planMons = GetPlanMonth(4);
            List<ProductionMasterPlan> productionMasters= new List<ProductionMasterPlan>();
            List<ProductionMasterPlan> pre3MonthPlan = _productionMasterPlan.GetListAsync(a => GetPlanMonth(-3).Contains(a.PlanMonth) && a.factory_id == input.factory_id).Result;
            //N0,N+1,N+2月度发货计划
            var annualProduction = _monthlyShipmentPlan.Select(x => planMons.Contains(x.PlanMonth) && !x.IsDeleted  && x.factory_id == input.factory_id).OrderBy(p => p.PlanMonth).ThenBy(o => o.OrderNum).ToList();
            var productionMasterPlan = _productionMasterPlan.GetListAsync(x => planMons.Contains(x.PlanMonth) && !x.IsDeleted  && x.factory_id == input.factory_id).Result.OrderBy(p => p.PlanMonth).ThenBy(o => o.OrderNum).ToList();
            List<InvMaster> locations = _invMaster.Select(x => annualProduction.Select(m => m.SAPItemNumber).Contains(x.ItemNum) && x.Domain == input.factory_id.ToString() && x.IsActive).ToList();
            var InProdcutQty=GetInProdcutQty(annualProduction.Select(m => m.SAPItemNumber).ToList(),input);
            var itemStock = CalcStock(annualProduction.Select(m => m.SAPItemNumber).ToList(),input);
            //主生产计划渠道合并，只考虑瑞奇库存不考虑国科海王库存
            List<MonthlyShipmentPlan> shipList = new List<MonthlyShipmentPlan>();
            foreach (var item in annualProduction)
            {
                if (shipList.Any(a => a.SAPItemNumber == item.SAPItemNumber && a.PlanMonth == item.PlanMonth))
                {
                    shipList.Find(b => b.SAPItemNumber == item.SAPItemNumber && b.PlanMonth == item.PlanMonth).Qty += item.Qty;
                }
                else
                {
                    shipList.Add(item);
                }
            }
            shipList.OrderBy(a => a.PlanMonth);
            var shipItemList= shipList.Select(a=>a.SAPItemNumber).Distinct().ToList();
            var ropPlan = _replenishmentROPWeekPlan.GetListAsync(x => shipItemList.Contains(x.number) && planMons.Contains(x.planmonth) && !x.IsDeleted && x.factory_id == input.factory_id).Result;
            foreach (var item in shipList)
            {
                var ropItem = ropPlan.Find(x => x.number == item.SAPItemNumber);
                ProductionMasterPlan plan = new ProductionMasterPlan();
                plan.Area = item.Area;
                plan.ProdLine = item.ProdLine;
                plan.ProdRange = item.ProdRange;
                plan.WorkshopLine = annual.Find(a=>a.PlanMonth==item.PlanMonth && a.SAPItemNumber==item.SAPItemNumber).WorkshopLine;
                plan.ItemNumber = item.SAPItemNumber;
                plan.Model = item.Model;
                plan.Languages = item.Languages;
                plan.PlanMonth = item.PlanMonth;
                plan.PlanShipQty = item.Qty;
                var preMonth = Convert.ToDateTime($"{plan.PlanMonth}-01").AddMonths(-1);
                var preMonthStr = $"{preMonth.Year}-{preMonth.Month}";
                var preMaster = productionMasters.Find(t => t.ItemNumber == plan.ItemNumber && t.PlanMonth == preMonthStr && t.factory_id == input.factory_id);
                var preStock = pre3MonthPlan.Find(t => t.ItemNumber == plan.ItemNumber && t.PlanMonth == preMonthStr && t.factory_id == input.factory_id);
                if (preMaster != null)
                {
                    plan.PlanProductQty = Math.Ceiling(item.Qty -
                    (
                     preMaster.PlanStockQty-
                     ropItem.security_stock.GetValueOrDefault()
                    ));//发货计划-(上个月期末库存作为本月期初库存-安全库存)
                    if(plan.PlanProductQty<0)
                    {
                        plan.PlanProductQty = 0;
                    }
                    plan.PlanStockQty =Math.Ceiling( preMaster.PlanStockQty + plan.PlanProductQty-item.Qty);
                }
                else if (preStock != null)
                {
                    plan.PlanProductQty =Math.Ceiling( item.Qty -
                    (
                     preStock.PlanStockQty -
                     ropItem.security_stock.GetValueOrDefault()
                    ));//发货计划-(上个月期末库存作为本月期初库存-安全库存)
                    if (plan.PlanProductQty < 0)
                    {
                        plan.PlanProductQty = 0;
                    }
                    plan.PlanStockQty = Math.Ceiling(preStock.PlanStockQty + plan.PlanProductQty - item.Qty);
                }
                else
                {
                    plan.PlanProductQty = item.Qty -
                    (
                    itemStock.Find(a => a.ItemNumber == item.SAPItemNumber).Qty +
                    InProdcutQty.Find(a => a.ItemNumber == item.SAPItemNumber).Qty -
                    ropItem.security_stock.GetValueOrDefault()
                    );//发货计划-(库存+在制-安全库存)
                    if (plan.PlanProductQty < 0)
                        plan.PlanProductQty = 0;
                    plan.PlanStockQty = Math.Ceiling(
                        itemStock.Find(a => a.ItemNumber == item.SAPItemNumber).Qty +
                           InProdcutQty.Find(a => a.ItemNumber == item.SAPItemNumber).Qty + 
                           plan.PlanProductQty - item.Qty);
                } 

                if (locations.FirstOrDefault(a => a.ItemNum == item.SAPItemNumber && a.Location == "8001")!=null)
                {
                    plan.Inventory = locations.Where(a => a.ItemNum == item.SAPItemNumber && a.Location == "8001").Sum(c => c.AvailStatusQty.GetValueOrDefault() + c.Assay.GetValueOrDefault());
                }else
                {
                    plan.Inventory = 0;
                }
                if (locations.FirstOrDefault(a => a.ItemNum == item.SAPItemNumber && a.Location == "8000") != null)
                {
                    plan.Inventory1 = locations.Where(a => a.ItemNum == item.SAPItemNumber && a.Location == "8000").Sum(c => c.AvailStatusQty.GetValueOrDefault() + c.Assay.GetValueOrDefault());
                }
                else
                {
                    plan.Inventory1 = 0;
                }
                if (locations.FirstOrDefault(a => a.ItemNum == item.SAPItemNumber && a.Location == "5008") != null)
                {
                    plan.Inventory2 = locations.Where(a => a.ItemNum == item.SAPItemNumber && a.Location == "5008").Sum(c => c.AvailStatusQty.GetValueOrDefault() + c.Assay.GetValueOrDefault());
                }
                else
                {
                    plan.Inventory2 = 0;
                }
                plan.DuringSterilization = 0;//TODO:灭菌中需要从委外订单接口获取
                plan.InProduction = InProdcutQty.Find(a=>a.ItemNumber==item.SAPItemNumber).Qty;
                if(pre3MonthPlan.Where(a => a.ItemNumber == item.SAPItemNumber).Count()>0)
                {
                    plan.EconomicLotSize = pre3MonthPlan.Where(a => a.ItemNumber == item.SAPItemNumber).Average(a => a.PlanProductQty);
                }else
                {
                    plan.EconomicLotSize = plan.PlanProductQty;
                }
                plan.tenant_id = input.tenant_id;
                plan.factory_id = input.factory_id;
                plan.company_id=input.company_id;
                plan.org_id = input.org_id;
                plan.create_time = DateTime.Now;
                plan.OrderNum =item.OrderNum;
                productionMasters.Add(plan);
            }
            //保存数据
            using (var unitOfWork = _unitOfWorkManager.Begin(false, true))
            {
                try
                {
                    var planList = productionMasters.Select(a => a.PlanMonth).ToList();
                    await _productionMasterPlan.DeleteAsync(a => planList.Contains(a.PlanMonth) && a.factory_id == input.factory_id);
                    await _productionMasterPlan.InsertManyAsync(productionMasters);
                    await unitOfWork.CompleteAsync();
                }
                catch (Exception e)
                {
                    unitOfWork.Dispose();
                    new NLogHelper("AnnualProductionOutlineAppService").WriteLog("SaveProductionMasterPlan", "【" + input.year + "年" + "】主计划生成失败：" + e.Message, _currentTenant.Id.ToString());
                    return "NO|" + e.Message;
                };
            }
            return "OK";
        }

        /// <summary>
        /// 获取物料在制数量
        /// </summary>
        /// <param name="itemNumbers"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        public List<EOPDto> GetInProdcutQty(List<string> itemNumbers,InputDto input)
        {
            List<EOPDto> itemQty = new List<EOPDto>();
            DateTime startYear = new DateTime(DateTime.Now.AddYears(-1).Year, 1, 1);
            DateTime endYear = new DateTime(DateTime.Now.Year, 12, 31);
            List<WorkOrdRouting> workOrdRoutings = _workOrdRouting.Select(x => x.IsActive && x.QtyComplete > 0 && x.Domain == input.factory_id.ToString()).Where(p => p.DueDate >= startYear && p.DueDate <= endYear).ToList();
            decimal? InProductionQty = 0.00m;
            var workOrds = workOrdRoutings.GroupBy(x => x.WorkOrd).ToList();
            Dictionary<string, decimal> dictInProduction = new Dictionary<string, decimal>();
            //按照工单循环
            //某工单10-90工序   Max（10-80工序QtyComplete）-90工序QtyComplete =在制数量
            foreach (var item in workOrds)
            {
                var workOrdRoutingList = workOrdRoutings.Where(x => x.WorkOrd == item.Key).OrderByDescending(o => o.OP).ToList();
                //找出最大工序
                var MaxOp = workOrdRoutingList.FirstOrDefault();
                //查询出其他工序最大值
                var MaxQtyComplete = workOrdRoutingList.Where(x => x.RecID != MaxOp.RecID).ToList().Max(o => o.QtyComplete);
                InProductionQty += MaxQtyComplete - MaxOp.QtyComplete;
                if (dictInProduction.ContainsKey(MaxOp.ItemNum))
                {
                    dictInProduction[MaxOp.ItemNum] += InProductionQty.Value;
                }
                else
                {
                    dictInProduction.Add(MaxOp.ItemNum, InProductionQty.Value);
                }
            }

            itemNumbers.ForEach(a =>
            {
                EOPDto eOP = new EOPDto();
                eOP.ItemNumber = a;
                eOP.Qty = 0;
                if(dictInProduction.ContainsKey(a))
                    eOP.Qty = dictInProduction[a];

                itemQty.Add(eOP);

            });
            return itemQty;
        }

        /// <summary>
        /// 更新年度生产大纲
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<string> DemandAnalysis(InputDto input)
        {
            string productResult=await SaveAnnualProductionOutline(input);
            if(productResult!="OK")
                return productResult;
            return "OK|刷新成功！";
        }

        /// <summary>
        /// 调整成品ROP和最高库存水位
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> CalcROP(InputDto input)
        {
            input.year = DateTime.Now.Year;
            input.month = DateTime.Now.Month;
            //1.获取补货模型全局参数
            ReplenishmentDto replenishmentDto = GetROPParam(input.factory_id.ToString());
            List<ReplenishmentROPWeekPlan> addList = new List<ReplenishmentROPWeekPlan>();
            List<ReplenishmentROPWeekPlan> updateList = new List<ReplenishmentROPWeekPlan>();//更新上一个月的实际出库数量
            List<ReplenishmentServiceLevel> addServiceLevelList = new List<ReplenishmentServiceLevel>();
            List<ReplenishmentServiceLevel> updateServiceLevelList = new List<ReplenishmentServiceLevel>();
            //获取存货周转率设置
            var turnOverlist = _ReplenishmentTurnOverSet.GetListAsync(a => a.factory_id == input.factory_id).Result;
            //获取补货模型前H周期和未来F个周期的数据
            List<string> planMonthList = new List<string>();
            for (int j = -replenishmentDto.HistoryOutStockMonth; j < replenishmentDto.SaleFcstMonth; j++)
            {
                string itemMonth = $"{DateTime.Now.AddMonths(j).Year}-{DateTime.Now.AddMonths(j).Month.ToString("00")}";
                planMonthList.Add(itemMonth);
            }
            var planList = _monthlyShipmentPlan.Select(a => planMonthList.Contains(a.PlanMonth) && !a.IsDeleted && a.factory_id == input.factory_id).ToList();

            //获取BOM用于分解到原材料
            var boms = _ic_bom.GetListAsync(a => planList.Select(p => p.SAPItemNumber).ToList().Contains(a.item_number) && a.factory_id == input.factory_id).Result;
            var pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            List<mo_ic_bom> autoCreates = new List<mo_ic_bom>();
            boms.ForEach(p =>
            {
                if (!pretreatments.Where(s => s.sourceid == p.mysql_id).Any())
                {
                    autoCreates.Add(p);
                }
            });
            if (autoCreates.Any())
            {
                AutoCreateBomBill(input.company_id.ToString(), autoCreates);
                pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            }
            
            var mesItemList = _itemMaster.Select(a => pretreatments.Select(p => p.item_number).Contains(a.ItemNum) && a.Domain == input.factory_id.ToString() && a.IsActive);
            var itemProductList = _mysql_ic_item.GetListAsync(a => pretreatments.Select(p => p.item_number).Contains(a.number) && !a.IsDeleted && a.factory_id == input.factory_id).Result;
            var itemList = itemProductList.Select(a => a.number).ToList();
            var srm_purchaseList = _srmPurchase.GetListAsync(a => pretreatments.Select(p => p.item_number).Contains(a.number) && !a.IsDeleted).Result;
            
            var ropModelList = _replenishmentROPWeekPlan.GetListAsync(a => itemList.Contains(a.number) && planMonthList.Contains(a.planmonth) && a.factory_id == input.factory_id).Result;

            //获取成品库存、灭菌库存、在制库存(会从SAP同步的库存表更新到LocationDetail、ic_item表中)
            var locations = _invMaster.Select(p => p.Domain == input.factory_id.ToString() && itemList.Contains(p.ItemNum) && p.IsActive);
            //国科海王只有成品
            var DMSItemList = _DMS_IN_ITEMMAPPING.Select(a => planList.Select(p => p.SAPItemNumber).ToList().Contains(a.CfnERPCode));
            var gkhwStock = _DMS_IN_LOCDETAIL.Select(a => (a.DealerCode == "RQ000005" || a.DealerCode == "RQ000002"));
            decimal? InProductionQty = 0.00m;
            //获取在制数量 获取工单数取每年4月到12月底的工单
            DateTime startYear = new DateTime(DateTime.Now.Year, 1, 1);
            DateTime endYear = new DateTime(DateTime.Now.Year, 12, 31);
            List<WorkOrdRouting> workOrdRoutings = _workOrdRouting.Select(x => x.IsActive && x.QtyComplete > 0 && x.Domain == input.factory_id.ToString()).Where(p => p.DueDate >= startYear && p.DueDate <= endYear).ToList();
            var workOrds = workOrdRoutings.GroupBy(x => x.WorkOrd).ToList();
            Dictionary<string, decimal> dictItemStock = new Dictionary<string, decimal>();
            //按照工单循环
            //某工单10-90工序   Max（10-80工序QtyComplete）-90工序QtyComplete =在制数量
            foreach (var item in workOrds)
            {
                var workOrdRoutingList = workOrdRoutings.Where(x => x.WorkOrd == item.Key).OrderByDescending(o => o.OP).ToList();
                //找出最大工序
                var MaxOp = workOrdRoutingList.FirstOrDefault();
                //查询出其他工序最大值
                var MaxQtyComplete = workOrdRoutingList.Where(x => x.RecID != MaxOp.RecID).ToList().Max(o => o.QtyComplete);
                InProductionQty += MaxQtyComplete - MaxOp.QtyComplete;
                if (dictItemStock.ContainsKey(MaxOp.ItemNum))
                {
                    dictItemStock[MaxOp.ItemNum] += InProductionQty.Value;
                }
                else
                {
                    dictItemStock.Add(MaxOp.ItemNum, InProductionQty.Value);
                }
            }
            foreach (var item in locations)
            {
                //库存合计 + 在制 + 灭菌中 TODO: 灭菌中取值待确定
                //5008成品线边库,8001成品合格库,8000成品待检
                if (item.Location == "5008" || item.Location == "8000" || item.Location == "8001")
                {
                    if (dictItemStock.ContainsKey(item.ItemNum))
                    {
                        dictItemStock[item.ItemNum] += (item.AvailStatusQty.GetValueOrDefault() + item.Assay.GetValueOrDefault());
                    }
                    else
                    {
                        dictItemStock.Add(item.ItemNum, (item.AvailStatusQty.GetValueOrDefault() + item.Assay.GetValueOrDefault()));
                    }
                }
            }
            foreach (var item in itemList)
            {
                if (!dictItemStock.ContainsKey(item))
                {
                    dictItemStock.Add(item, 0);
                }
            }
            //取过去6个月成品发货出库记录
            var dateBegin = DateTime.Now.AddMonths(-6);
            var datePreBegin = DateTime.Now.AddMonths(-1);
            var dateEnd = DateTime.Now;
            //获取瑞奇发往国科海王的记录
            var gkhwList = _ASNBOLShipperMaster.Select(a => a.Domain == input.factory_id.ToString() && (a.SoldTo == "10002080" || a.SoldTo == "10001981"));
            var recidList = gkhwList.Select(a => a.RecID).ToList();
            //获取瑞奇发货记录
            var shipList = _ASNBOLShipperDetail.Select(a => a.Domain == input.factory_id.ToString() && a.IsActive && a.shtype == "SH" && a.Typed != "S" && a.RealQty > 0
            && itemList.Contains(a.ContainerItem) && a.ShipDate >= dateBegin && a.ShipDate <= dateEnd && !recidList.Contains(a.ASNBOLShipperRecID));//瑞奇只算瑞奇排除国科海王
            //获取瑞奇上月发货记录
            var shipMList = shipList.Where(a => a.ShipDate >= datePreBegin && a.ShipDate <= dateEnd).ToList();//瑞奇只算瑞奇排除国科海王
            //获取国科海王发货记录
            var gkItemList = planList.Where(p => p.DistributionChannel == "国科").Select(p => p.SAPItemNumber).ToList();
            var DMSItemListGK = _DMS_IN_ITEMMAPPING.Select(a => gkItemList.Contains(a.CfnERPCode));
            var shipListGK = _DMS_IN_SHIPPINGDETAIL.Select(a =>
            DMSItemListGK.Select(g => g.CfnCode).Contains(a.UPN) && a.ParentDealerCode == "RQ000005" && a.ShipmentDate >= DateOnly.FromDateTime(dateBegin) && a.ShipmentDate <= DateOnly.FromDateTime(dateEnd));//国科
            var hwItemList = planList.Where(p => p.DistributionChannel == "海王").Select(p => p.SAPItemNumber).ToList();
            var DMSItemListHW = _DMS_IN_ITEMMAPPING.Select(a => hwItemList.Contains(a.CfnERPCode));
            var shipListHW = _DMS_IN_SHIPPINGDETAIL.Select(a =>
            DMSItemListHW.Select(g => g.CfnCode).Contains(a.UPN) && a.ParentDealerCode == "RQ000002" && a.ShipmentDate >= DateOnly.FromDateTime(dateBegin) && a.ShipmentDate <= DateOnly.FromDateTime(dateEnd));//海王

            //领料出库记录
            var pickbilllist = _invTransHist.Select(a => a.Domain == input.factory_id.ToString() && a.TransType == "iss-wo" && a.IsActive
            && a.CreateTime >= dateBegin && itemList.Contains(a.ItemNum));
           
            var gkCNCCodeList = DMSItemListGK.Select(g => g.CfnCode).ToList();
            var dateOnlyCurrent = DateOnly.FromDateTime(datePreBegin);
            var dateOnlyNow = DateOnly.FromDateTime(dateEnd);
            var shipMListGK = _DMS_IN_SHIPPINGDETAIL.Select(a =>
           gkCNCCodeList.Contains(a.UPN) && a.ParentDealerCode == "RQ000005" && a.ShipmentDate >= dateOnlyCurrent && a.ShipmentDate <= dateOnlyNow);//国科
            var hwCNCCodeList = DMSItemListHW.Select(g => g.CfnCode).ToList();
            var shipMListHW = _DMS_IN_SHIPPINGDETAIL.Select(a =>
           hwCNCCodeList.Contains(a.UPN) && a.ParentDealerCode == "RQ000002" && a.ShipmentDate >= dateOnlyCurrent && a.ShipmentDate <= dateOnlyNow);//海王

            var itemGroup = shipList.GroupBy(p => p.ContainerItem)
                 .Select(p => new ASNBOLShipperDetail
                 {
                     QtyToShip = p.Sum(a => a.QtyToShip),
                     ContainerItem = p.Key
                 }).ToList();
            var itemMGroup = shipMList.GroupBy(p => p.ContainerItem)
                 .Select(p => new ASNBOLShipperDetail
                 {
                     QtyToShip = p.Sum(a => a.QtyToShip),
                     ContainerItem = p.Key
                 }).ToList();

            var itemGroupGK = shipListGK.GroupBy(p => p.UPN)
                .Select(p => new ASNBOLShipperDetail
                {
                    QtyToShip = p.Sum(a => a.Qty),
                    ContainerItem = p.Key
                }).ToList();
            var itemMGroupGK = shipMListGK.GroupBy(p => p.UPN)
                 .Select(p => new ASNBOLShipperDetail
                 {
                     QtyToShip = p.Sum(a => a.Qty),
                     ContainerItem = p.Key
                 }).ToList();

            var itemGroupHW = shipListHW.GroupBy(p => p.UPN)
                .Select(p => new ASNBOLShipperDetail
                {
                    QtyToShip = p.Sum(a => a.Qty),
                    ContainerItem = p.Key
                }).ToList();
            var itemMGroupHW = shipMListHW.GroupBy(p => p.UPN)
                 .Select(p => new ASNBOLShipperDetail
                 {
                     QtyToShip = p.Sum(a => a.Qty),
                     ContainerItem = p.Key
                 }).ToList();

           
            var mathtool = new MathNet.Numerics.Distributions.Normal();

            //更新上个月计划发货数据为实际出库数据(先算成品，原材料后面单独计算)
            Dictionary<string, decimal?> preMonthRQQty = new Dictionary<string, decimal?>();
            ropModelList?.Where(r => r.year == DateTime.Now.AddMonths(-1).Year && r.month == DateTime.Now.AddMonths(-1).Month).ToList()?.ForEach
                (m =>
                {
                    //只更新成品
                    if(planList.Any(a=>a.SAPItemNumber==m.number))
                    {
                        if (m.distributionchannel == "瑞奇")
                        {
                            preMonthRQQty.Add(m.number, m.plan_out_qty);
                            //成品算销售出库数量
                            if (itemGroup.Any(a => a.ContainerItem == m.number))
                            {
                                m.plan_out_qty = itemGroup.Find(a => a.ContainerItem == m.number)?.QtyToShip;
                                updateList.Add(m);
                                preMonthRQQty[m.number] = m.plan_out_qty;
                            }
                        }
                        else if (m.distributionchannel == "国科")
                        {
                            if (itemGroupGK.Any(a => a.ContainerItem == m.number))
                            {
                                m.plan_out_qty = itemGroupGK.Find(a => a.ContainerItem == m.number)?.QtyToShip;
                                updateList.Add(m);
                            }
                        }
                        else if (m.distributionchannel == "海王")
                        {
                            if (itemGroupHW.Any(a => a.ContainerItem == m.number))
                            {
                                m.plan_out_qty = itemGroupHW.Find(a => a.ContainerItem == m.number)?.QtyToShip;
                                updateList.Add(m);
                            }
                        }
                    }
                });

            //更新瑞奇原材料上个月出库次数(按照BOM展开合计汇总)
            string planPreMonth = $"{DateTime.Now.AddMonths(-1).Year}-{DateTime.Now.AddMonths(-1).Month.ToString("00")}";
            Dictionary<string, decimal?> subItem = new Dictionary<string, decimal?>();
            planList.Where(a => a.DistributionChannel == "瑞奇" && a.PlanMonth == planPreMonth).ToList().ForEach(a =>
            {
                var planBOM = boms.Find(b => b.item_number == a.SAPItemNumber);
                var pretreament = pretreatments.Where(c => c.sourceid == planBOM.mysql_id).ToList();
                var returnlist = ObjectMapper.Map<List<b_bom_pretreatment>,List<BomChildExamineDto>>(pretreament);
                returnlist = returnlist.OrderBy(s => s.num_order).ToList();
                var level1Dto = returnlist[0];
                if (preMonthRQQty.ContainsKey(a.SAPItemNumber))
                {
                    level1Dto.needCount = preMonthRQQty[a.SAPItemNumber].GetValueOrDefault();
                }else
                {
                    level1Dto.needCount = a.Qty;
                }
                CaclMaterialShortage(returnlist);
                foreach(var item in returnlist)
                {
                    if(subItem.ContainsKey(item.item_number))
                    {
                        subItem[item.item_number] += item.needCount;
                    }else
                    {
                        subItem.Add(item.item_number,item.needCount);
                    }
                }
            });
            ropModelList?.Where(r => r.year == DateTime.Now.AddMonths(-1).Year && r.month == DateTime.Now.AddMonths(-1).Month && r.distributionchannel=="瑞奇").ToList()?.ForEach
                (m =>
                {
                    //只更新原材料
                    if (!planList.Any(a => a.SAPItemNumber == m.number) && subItem.ContainsKey(m.number))
                    {
                        m.plan_out_qty = subItem[m.number];
                        updateList.Add(m);
                    }
                });

            var serviceList = _replenishmentServiceLevel.GetListAsync(a => a.factory_id == input.factory_id).Result;

            for (int j = 0; j < replenishmentDto.SaleFcstMonth; j++)
            {
                string itemMonth = $"{DateTime.Now.AddMonths(j).Year}-{DateTime.Now.AddMonths(j).Month.ToString("00")}";
                //先计算成品
                planList?.Where(s => s.PlanMonth == itemMonth).ToList()?.ForEach(a =>
                {
                    var icItem = itemProductList.Find(s => s.number == a.SAPItemNumber);
                    if (icItem != null)
                    {
                        bool isExist = ropModelList.Find(r => r.planmonth == itemMonth && r.number == a.SAPItemNumber &&r.distributionchannel==a.DistributionChannel) == null ? false : true;
                        var rop = new ReplenishmentROPWeekPlan();
                        if (isExist)
                        {
                            rop = ropModelList.Find(r => r.planmonth == itemMonth && r.number == a.SAPItemNumber &&r.distributionchannel==a.DistributionChannel);
                        }
                        rop.number = a.SAPItemNumber;
                        rop.name = icItem.name;
                        rop.model = a.Model;
                        rop.erp_cls = icItem.erp_cls; //物料属性: 0.配置类 1.自制 2.委外加工 3.外购 4.虚拟件
                        rop.fversion = icItem.fversion;
                        rop.min_pack_qty = icItem.minpackqty;
                        rop.moq = icItem.moq;
                        rop.distributionchannel = a.DistributionChannel;
                        rop.lifecycle = a.LifeCycle;
                        rop.area = a.Area;
                        rop.plan_out_qty = Math.Ceiling(a.Qty);
                        if (planList.Where(i => i.SAPItemNumber == a.SAPItemNumber && i.DistributionChannel == a.DistributionChannel).Count() > 0)
                        {
                            rop.monthl_avg_demand = planList.Where(i => i.SAPItemNumber == a.SAPItemNumber && i.DistributionChannel == a.DistributionChannel).Average(a => a.Qty);
                            var nums = planList.Where(i => i.SAPItemNumber == a.SAPItemNumber && i.DistributionChannel == a.DistributionChannel).Select(a => a.Qty);
                            if (nums.Count() <= 1)
                            {
                                rop.monthl_avg_demand_variance = 0;
                            }
                            else
                            {
                                rop.monthl_avg_demand_variance = Math.Ceiling(Convert.ToDecimal(Math.Sqrt(nums.Sum(x => Math.Pow(Convert.ToDouble(x) - Convert.ToDouble(rop.monthl_avg_demand), 2)) / (nums.Count() - 1))));
                            }
                        }
                        else
                        {
                            rop.monthl_avg_demand = 0;
                            rop.monthl_avg_demand_variance = 0;
                        }

                        //计算月均出库
                        int MonthCount = 0;
                        decimal SumOutQty = 0;
                        for (int k = -1 * replenishmentDto.HistoryOutStockMonth; k < replenishmentDto.SaleFcstMonth; k++)
                        {
                            string itemMonth = $"{DateTime.Now.AddMonths(k).Year}-{DateTime.Now.AddMonths(k).Month.ToString("00")}";
                            if (k < 0)
                            {
                                if (ropModelList.Find(z => z.planmonth == itemMonth && z.number == a.SAPItemNumber && z.distributionchannel==a.DistributionChannel) != null)
                                {
                                    SumOutQty += ropModelList.Find(z => z.planmonth == itemMonth && z.number == a.SAPItemNumber && z.distributionchannel==a.DistributionChannel).plan_out_qty.GetValueOrDefault();
                                    MonthCount++;
                                }
                            }
                            else
                            {
                                if (planList.Find(z => z.PlanMonth == itemMonth && z.SAPItemNumber == a.SAPItemNumber && z.DistributionChannel==a.DistributionChannel) != null)
                                {
                                    SumOutQty += planList.Find(z => z.PlanMonth == itemMonth && z.SAPItemNumber == a.SAPItemNumber && z.DistributionChannel==a.DistributionChannel).Qty;
                                    MonthCount++;
                                }
                            }
                        }
                        if(MonthCount==0)
                        {
                            rop.monthl_avg_outstock = 0;
                        }else
                        {
                            rop.monthl_avg_outstock = Math.Ceiling(SumOutQty / MonthCount);
                        }
                        rop.year = DateTime.Now.AddMonths(j).Year;
                        rop.month = DateTime.Now.AddMonths(j).Month;
                        rop.planmonth = $"{DateTime.Now.AddMonths(j).Year}-{DateTime.Now.AddMonths(j).Month.ToString("00")}";
                        //供应提前期，成品取物料主数据维护的，原材料从货源清单取取不到取物料维护的
                        if(icItem.erp_cls==1)
                        {
                            rop.supply_leadtime = icItem.PurLT;//默认
                        }else
                        {
                            if (srm_purchaseList.Find(s => s.number ==rop.number) != null)
                            {
                                rop.supply_leadtime = srm_purchaseList.Find(s => s.number == rop.number).lead_time;
                            }else
                            {
                                rop.supply_leadtime = icItem.PurLT;//默认
                            }
                        }
                        if(rop.supply_leadtime==0)
                            rop.supply_leadtime = 22;//默认
                        //存货周转率先取规格型号，没有再取产品系列，没有取产品线，再没有取物料配置的(主要是原材料)，再没有就默认
                        if (turnOverlist.Find(t => t.Model == rop.model) != null)
                        {
                            rop.stock_turnover = turnOverlist.Find(t => t.Model == rop.model).RQTurnOver;
                        }
                        else if (turnOverlist.Find(t => t.ProdRange == a.ProdRange) != null)
                        {
                            rop.stock_turnover = turnOverlist.Find(t => t.ProdRange == a.ProdRange).RQTurnOver;
                        }
                        else if (turnOverlist.Find(t => t.ProdLine == a.ProdLine) != null)
                        {
                            rop.stock_turnover = turnOverlist.Find(t => t.ProdLine == a.ProdLine).RQTurnOver;
                        }
                        else if (mesItemList.Find(s => s.ItemNum == a.SAPItemNumber) != null)
                        {
                            rop.stock_turnover = mesItemList.Find(s => s.ItemNum == a.SAPItemNumber).StockTurnOver;
                        }
                        else
                        {
                            rop.stock_turnover = 4;
                        }
                        CalcFMRAndABC(rop, replenishmentDto, shipList, pickbilllist, input);
                        rop.security_stock = Math.Ceiling((decimal)(mathtool.InverseCumulativeDistribution((double)rop.service_level_pct.Value) * (double)rop.monthl_avg_demand_variance));

                        rop.eop = Math.Ceiling(rop.monthl_avg_demand.Value * rop.supply_leadtime.Value / DateTime.DaysInMonth(DateTime.Now.AddMonths(j).Year, DateTime.Now.AddMonths(months: j).Month));
                        rop.rop_computed = rop.security_stock + rop.eop;
                        rop.max_stock_level = rop.monthl_avg_outstock * (12 / rop.stock_turnover);
                        //瑞奇是ROP和最高库存值两者之间取较小的值，平台是取较大的值。
                        if (a.DistributionChannel != "瑞奇")
                        {
                            rop.rop_revised = Math.Max(rop.rop_computed.Value, rop.max_stock_level.Value);
                        }
                        else
                        {
                            rop.rop_revised = Math.Min(rop.rop_computed.Value, rop.max_stock_level.Value);
                        }

                        //存在上一个月补货
                        if (updateList.Find(r => r.number == a.SAPItemNumber && r.distributionchannel==a.DistributionChannel && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}") != null)
                        {
                            var avaItem = updateList.Find(r => r.number == a.SAPItemNumber && r.distributionchannel == a.DistributionChannel && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}");
                            rop.avaStockQty = Math.Ceiling(avaItem.avaStockQty.GetValueOrDefault() + avaItem.montheop1.GetValueOrDefault() + avaItem.montheop2.GetValueOrDefault() - a.Qty);
                        }
                        else if (addList.Find(r => r.number == a.SAPItemNumber && r.distributionchannel == a.DistributionChannel && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}") != null)
                        {
                            var avaItem = addList.Find(r => r.number == a.SAPItemNumber && r.distributionchannel == a.DistributionChannel && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}");
                            rop.avaStockQty = Math.Ceiling(avaItem.avaStockQty.GetValueOrDefault() + avaItem.montheop1.GetValueOrDefault() + avaItem.montheop2.GetValueOrDefault() - a.Qty);
                        }
                        else
                        {
                            //取实际库存
                            if (a.DistributionChannel == "海王")
                            {
                                if (DMSItemList.Find(d => d.CfnERPCode == rop.number) != null)
                                {
                                    var itemDMS = gkhwStock.Where(o => o.UPN == DMSItemList.Find(d => d.CfnERPCode == rop.number).CfnCode && o.DealerCode == "RQ000002").ToList();
                                    if (itemDMS.Count > 0)
                                    {
                                        var maxDate = itemDMS.OrderByDescending(i => i.InventoryDate).First();
                                        rop.avaStockQty = itemDMS.Where(i => i.InventoryDate == maxDate.InventoryDate).Sum(q => q.Qty);
                                    }
                                }
                            }
                            else if (a.DistributionChannel == "国科")
                            {
                                if (DMSItemList.Find(d => d.CfnERPCode == rop.number) != null)
                                {
                                    var itemDMS = gkhwStock.Where(o => o.UPN == DMSItemList.Find(d => d.CfnERPCode == rop.number).CfnCode && o.DealerCode == "RQ000005").ToList();
                                    if (itemDMS.Count > 0)
                                    {
                                        var maxDate = itemDMS.OrderByDescending(i => i.InventoryDate).First();
                                        rop.avaStockQty = itemDMS.Where(i => i.InventoryDate == maxDate.InventoryDate).Sum(q => q.Qty);
                                    }
                                }
                            }
                            else
                            {
                                rop.avaStockQty = dictItemStock[a.SAPItemNumber];
                            }
                        }
                        if (rop.avaStockQty < 0)
                        {
                            string test = "";
                        }
                        rop.montheop1 = rop.rop_computed > rop.avaStockQty.GetValueOrDefault() ? rop.eop : 0;
                        rop.montheop2 = rop.security_stock > rop.avaStockQty.GetValueOrDefault() ? rop.eop : 0;
                        rop.ProdLine = a.ProdLine;
                        rop.ProdRange = a.ProdRange;
                        rop.Languages = a.Languages;
                        rop.tenant_id = input.tenant_id;
                        rop.company_id = input.company_id;
                        rop.factory_id = input.factory_id;
                        rop.create_time = DateTime.Now;
                        rop.org_id = input.org_id;
                        if (isExist)
                        {
                            updateList.Add(rop);
                        }
                        else
                        {
                            addList.Add(rop);
                        }
                    }
                });
                //计算原材料
                planList?.Where(s => s.PlanMonth == itemMonth && s.DistributionChannel=="瑞奇").ToList()?.ForEach(a =>
                {
                    foreach (var d in subItem)
                    {
                        var icItem = itemProductList.Find(s => s.number == d.Key);
                        if (icItem != null && !planList.Select(r => r.SAPItemNumber).ToList().Contains(d.Key))
                        {
                            bool isExist = ropModelList.Find(r => r.planmonth == itemMonth && r.number == d.Key && r.distributionchannel=="瑞奇") == null ? false : true;
                            var rop = new ReplenishmentROPWeekPlan();
                            if (isExist)
                            {
                                rop = ropModelList.Find(r => r.planmonth == itemMonth && r.number == d.Key && r.distributionchannel == "瑞奇");
                            }
                            rop.number = d.Key;
                            rop.name = icItem.name;
                            rop.model = icItem.model;
                            rop.erp_cls = icItem.erp_cls; //物料属性: 0.配置类 1.自制 2.委外加工 3.外购 4.虚拟件
                            rop.fversion = icItem.fversion;
                            rop.min_pack_qty = icItem.minpackqty;
                            rop.moq = icItem.moq;
                            rop.distributionchannel = a.DistributionChannel;
                            rop.lifecycle = a.LifeCycle;
                            rop.area = a.Area;
                            rop.plan_out_qty = Math.Ceiling(d.Value.GetValueOrDefault());
                            //月均需求用几个月的发货计划按照bom展开合计计算
                            var subQty = CalcSubItemAvaQty(planList.Where(p=> p.PlanMonth == itemMonth && p.DistributionChannel=="瑞奇").ToList(), a.SAPItemNumber, boms, pretreatments);
                            if (subQty.ContainsKey(rop.number))
                            {
                                rop.monthl_avg_demand = subQty[rop.number];
                                rop.monthl_avg_demand_variance = CalcSubStdEV(planList.Where(p => p.PlanMonth == itemMonth && p.DistributionChannel == "瑞奇").ToList(), a.SAPItemNumber, rop.number, rop.monthl_avg_demand.GetValueOrDefault(), boms, pretreatments);
                            }
                            else
                            {
                                rop.monthl_avg_demand = 0;
                                rop.monthl_avg_demand_variance = 0;
                            }
                            //计算原材料月均出库
                            rop.monthl_avg_outstock = Math.Ceiling(pickbilllist.Where(z=>z.ItemNum==rop.number).Sum(q=>q.QtyChange.GetValueOrDefault()*-1)/6);
                            rop.year = DateTime.Now.AddMonths(j).Year;
                            rop.month = DateTime.Now.AddMonths(j).Month;
                            rop.planmonth = $"{DateTime.Now.AddMonths(j).Year}-{DateTime.Now.AddMonths(j).Month.ToString("00")}";
                            //供应提前期，成品取物料主数据维护的，原材料从货源清单取取不到取物料维护的
                            if (icItem.erp_cls == 1)
                            {
                                rop.supply_leadtime = icItem.PurLT;//默认
                            }
                            else
                            {
                                if (srm_purchaseList.Find(s => s.number == rop.number) != null)
                                {
                                    rop.supply_leadtime = srm_purchaseList.Find(s => s.number == rop.number).lead_time;
                                }
                                else
                                {
                                    rop.supply_leadtime = icItem.PurLT;//默认
                                }
                            }
                            if(rop.supply_leadtime==0)
                                rop.supply_leadtime = 22;//默认
                            //原材料周转率取物料
                            if (mesItemList.Find(s => s.ItemNum ==rop.number) != null)
                            {
                                rop.stock_turnover = mesItemList.Find(s => s.ItemNum == rop.number).StockTurnOver;
                                if(rop.stock_turnover==0)
                                {
                                    rop.stock_turnover = 4;
                                }
                            }
                            else
                            {
                                rop.stock_turnover = 4;
                            }
                            if (rop.stock_turnover == 0)
                                rop.stock_turnover = 4;
                            CalcFMRAndABC(rop, replenishmentDto, shipList, pickbilllist, input);
                            rop.security_stock = Math.Ceiling((decimal)(mathtool.InverseCumulativeDistribution((double)rop.service_level_pct.Value) * (double)rop.monthl_avg_demand_variance));

                            rop.eop = Math.Ceiling(rop.monthl_avg_demand.Value * rop.supply_leadtime.Value / DateTime.DaysInMonth(DateTime.Now.AddMonths(j).Year, DateTime.Now.AddMonths(j).Month));
                            rop.rop_computed = rop.security_stock + rop.eop;
                            rop.max_stock_level = rop.monthl_avg_outstock * (12 / rop.stock_turnover);
                            //瑞奇是ROP和最高库存值两者之间取较小的值，平台是取较大的值。
                            //瑞奇是ROP和最高库存值两者之间取较小的值，平台是取较大的值。
                            if (a.DistributionChannel != "瑞奇")
                            {
                                rop.rop_revised = Math.Max(rop.rop_computed.Value, rop.max_stock_level.Value);
                            }
                            else
                            {
                                rop.rop_revised = Math.Min(rop.rop_computed.Value, rop.max_stock_level.Value);
                            }
                     

                            //存在上一个月补货
                            if (updateList.Find(r => r.number == a.SAPItemNumber && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}") != null)
                            {
                                var avaItem = updateList.Find(r => r.number == a.SAPItemNumber && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}");
                                rop.avaStockQty = Math.Ceiling(avaItem.avaStockQty.GetValueOrDefault() + avaItem.montheop1.GetValueOrDefault() + avaItem.montheop2.GetValueOrDefault() - a.Qty);
                            }
                            else if (addList.Find(r => r.number == a.SAPItemNumber && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}") != null)
                            {
                                var avaItem = addList.Find(r => r.number == a.SAPItemNumber && r.planmonth == $"{DateTime.Now.AddMonths(j - 1).Year}-{DateTime.Now.AddMonths(j - 1).Month.ToString("00")}");
                                rop.avaStockQty = Math.Ceiling(avaItem.avaStockQty.GetValueOrDefault() + avaItem.montheop1.GetValueOrDefault() + avaItem.montheop2.GetValueOrDefault() - a.Qty);
                            }
                            else
                            {
                                //取实际库存
                                //1开始的库位为原料仓
                                rop.avaStockQty = locations.Where(a=>a.ItemNum==rop.number && a.Location.StartsWith("1")).Sum(a=> a.AvailStatusQty.GetValueOrDefault() + a.Assay.GetValueOrDefault());
                            }
                            rop.montheop1 = rop.rop_computed > rop.avaStockQty.GetValueOrDefault() ? rop.eop : 0;
                            rop.montheop2 = rop.security_stock > rop.avaStockQty.GetValueOrDefault() ? rop.eop : 0;
                            rop.ProdLine = a.ProdLine;
                            rop.ProdRange = a.ProdRange;
                            rop.Languages = a.Languages;
                            rop.tenant_id = input.tenant_id;
                            rop.company_id = input.company_id;
                            rop.factory_id = input.factory_id;
                            rop.create_time = DateTime.Now;
                            rop.org_id = input.org_id;
                            if (isExist)
                            {
                                updateList.Add(rop);
                            }
                            else
                            {
                                addList.Add(rop);
                            }
                        }
                    }
                });
            }
            addList?.ForEach(item => { item.GenerateNewId(help.NextId()); });
            await _replenishmentROPWeekPlan.InsertManyAsync(addList);
            await _replenishmentROPWeekPlan.UpdateManyAsync(updateList);
            await CalcWeekPlan(input);
            return "OK";
        }
        //计算原材料月均出库
        public Dictionary<string,decimal> CalcSubItemAvaQty(List<MonthlyShipmentPlan> planList,string ItemNum,List<mo_ic_bom> boms, List<b_bom_pretreatment> pretreatments)
        {
            Dictionary<string, decimal> subItem = new Dictionary<string, decimal>();
            var sumQty = planList.Where(c=>c.SAPItemNumber== ItemNum).Sum(a => a.Qty);
            var planBOM = boms.Find(b => b.item_number == ItemNum);
            var pretreament = pretreatments.Where(c => c.sourceid == planBOM.mysql_id).ToList();
            var returnlist = ObjectMapper.Map<List<b_bom_pretreatment>, List<BomChildExamineDto>>(pretreament);
            returnlist = returnlist.OrderBy(s => s.num_order).ToList();
            var level1Dto = returnlist[0];
            level1Dto.needCount = sumQty;
            CaclMaterialShortage(returnlist);
            foreach (var item in returnlist)
            {
                if (subItem.ContainsKey(item.item_number))
                {
                    subItem[item.item_number] += item.needCount;
                }
                else
                {
                    if(item.item_number!=ItemNum)
                    {
                        subItem.Add(item.item_number, item.needCount);
                    }
                }
            }
            return subItem;
        }

        //计算原材料方差
        public decimal CalcSubStdEV(List<MonthlyShipmentPlan> planList, string ItemNum,string subItemNum,decimal avaRequire, List<mo_ic_bom> boms, List<b_bom_pretreatment> pretreatments)
        {
            List<decimal> MonthItem = new List<decimal>();
            var planMonthList = planList.Where(a => a.SAPItemNumber == ItemNum).ToList().Select(a => a.PlanMonth).Distinct().ToList();
            
            for(int j=0;j<planMonthList.Count();j++)
            {
                Dictionary<string, decimal> subItem = new Dictionary<string, decimal>();
                var sumQty = planList.Find(c => c.SAPItemNumber == ItemNum && c.PlanMonth == planMonthList[j]).Qty;
                var planBOM = boms.Find(b => b.item_number == ItemNum);
                var pretreament = pretreatments.Where(c => c.sourceid == planBOM.mysql_id).ToList();
                var returnlist = ObjectMapper.Map<List<b_bom_pretreatment>, List<BomChildExamineDto>>(pretreament);
                returnlist = returnlist.OrderBy(s => s.num_order).ToList();
                var level1Dto = returnlist[0];
                level1Dto.needCount = sumQty;
                CaclMaterialShortage(returnlist);
                foreach (var item in returnlist)
                {
                    if (subItem.ContainsKey(item.item_number))
                    {
                        subItem[item.item_number] += item.needCount;
                    }
                    else
                    {
                        if(item.item_number!=ItemNum)
                        {
                            subItem.Add(item.item_number, item.needCount);
                        }
                    }
                }
                if(subItem.ContainsKey(subItemNum))
                {
                    MonthItem.Add(subItem[subItemNum]);
                }
            }
            if(MonthItem.Count<=1)
            {
                return 0;
            }else
            {
                return Math.Ceiling(Convert.ToDecimal(Math.Sqrt(MonthItem.Sum(x => Math.Pow(Convert.ToDouble(x) - Convert.ToDouble(avaRequire), 2)) / (MonthItem.Count() - 1))));
            }
        }
        /// <summary>
        /// 平铺计算物料情况
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="item"></param>
        /// <param name="count"></param>
        public void CaclMaterialShortage(List<BomChildExamineDto> returnlist)
        {
            foreach (var item in returnlist)
            {
                if (item.level == 1)
                {
                    continue;
                }
                //循环平铺整个资源检查的物料库存情况、缺料情况，子集缺料需要用父级缺料*子集使用数量-
                var parent = returnlist.Find(s => s.fid == item.parent_id);
                //当前物料总共需要数量
                item.needCount = Math.Ceiling(parent.needCount * item.qty * (1 + (item.Scrap.GetValueOrDefault() / 100)) + item.wastage.GetValueOrDefault());
                item.needCountNoloss = parent.needCount * item.qty;
            }
        }

        /// <summary>
        /// 根据月计划生产周计划
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> CalcWeekPlan(InputDto input)
        {
            //1.获取补货模型全局参数
            ReplenishmentDto replenishmentDto = GetROPParam(input.factory_id.ToString());
            //发货计划列表，用于判断成品物料编码
            //获取补货模型前H周期和未来F个周期的数据
            List<string> planMonthList = new List<string>();
            for (int j = -replenishmentDto.HistoryOutStockMonth; j < replenishmentDto.SaleFcstMonth; j++)
            {
                string itemMonth = $"{DateTime.Now.AddMonths(j).Year}-{DateTime.Now.AddMonths(j).Month.ToString("00")}";
                planMonthList.Add(itemMonth);
            }
            var shipPlanList = _monthlyShipmentPlan.Select(a => planMonthList.Contains(a.PlanMonth) && !a.IsDeleted && a.factory_id == input.factory_id).ToList();

            //滚动三个月12周的周计划，已经发布的周计划不改(TODO:删除未来未发布的周计划和工单(是否影响资源检查)) 
            //最小经济批量
            var weekPlanDelete = _replenishmentWeekPlan.GetListAsync(a => planMonthList.Contains(a.PlanMonth) && a.ProductionStatus != "已发布" && a.IsReplenishmentModel == "N" && a.factory_id == input.factory_id).Result;
            var workOrderDelete = weekPlanDelete.Select(b => b.ProductionOrder).ToList();
            _workOrdMaster.Delete(a => workOrderDelete.Contains(a.WorkOrd) && a.Domain == input.factory_id.ToString());
            _workOrdRouting.Delete(a => workOrderDelete.Contains(a.WorkOrd) && a.Domain == input.factory_id.ToString());
            _workOrdDetail.Delete(a => workOrderDelete.Contains(a.WorkOrd) && a.Domain == input.factory_id.ToString());
            var deletedOrderList=_mysql_mes_morder.GetListAsync(a=>workOrderDelete.Contains(a.morder_no) && a.factory_id == input.factory_id).Result;
            var deletedIds = deletedOrderList.Select(a => a.Id).ToList();
            await _mysql_mes_morder.HardDeleteAsync(deletedOrderList);
            var deletedEntryList= _mysql_mes_moentry.GetListAsync(a => workOrderDelete.Contains(a.moentry_mono) && a.factory_id == input.factory_id).Result;
            await _mysql_mes_moentry.HardDeleteAsync(deletedEntryList);
            var examine_result = _mysql_examine_result.GetListAsync(a => workOrderDelete.Contains(a.morder_no) && a.factory_id == input.factory_id).Result;
            List<srm_po_occupy> occupy = await _mysql_srm_po_occupy.GetListAsync(s => workOrderDelete.Contains(s.morder_mo));
            _businessDbContext.BulkDelete(occupy);
            //清理工单占用
            List<mes_mooccupy> mooccupy = await _mysql_mes_mooccupy.GetListAsync(s => deletedIds.Contains(s.moo_id.GetValueOrDefault()));
            if (mooccupy.Any())
            {
                _businessDbContext.BulkDelete(mooccupy);
            }
            //清理掉库存占用
            var itemstockoccupy = _mysql_ic_item_stockoccupy.GetListAsync(s => workOrderDelete.Contains(s.morder_mo)).Result;
            if (itemstockoccupy.Any())
            {
                _businessDbContext.BulkDelete(itemstockoccupy);
            }
            await _mysql_bom_child_examine.HardDeleteAsync(a => examine_result.Select(b => b.Id).ToList().Contains(a.examine_id.Value) && a.factory_id == input.factory_id);
            await _mysql_examine_result.HardDeleteAsync(examine_result);
            await _replenishmentWeekPlan.HardDeleteAsync(weekPlanDelete);

            //月度补货模型
            var planList = _replenishmentROPWeekPlan.GetListAsync(a => planMonthList.Contains(a.planmonth) && !a.IsDeleted && a.factory_id == input.factory_id).Result;
            //周补货计划
            var weekPlanList = _replenishmentWeekPlan.GetListAsync(a => planMonthList.Contains(a.PlanMonth) && !a.IsDeleted && a.factory_id == input.factory_id && a.IsReplenishmentModel == "Y").Result;
            //周生产计划
            var weekProductPlanList = _replenishmentWeekPlan.GetListAsync(a => planMonthList.Contains(a.PlanMonth) && !a.IsDeleted && a.factory_id == input.factory_id && a.IsReplenishmentModel == "N").Result;
            //发货计划物料列表
            List<string> planItemList = shipPlanList?.Select(a => a.SAPItemNumber).Distinct().ToList();
            var itemList = _mysql_ic_item.GetListAsync(a => planItemList.Contains(a.number) && !a.IsDeleted).Result;
            var bomList = _mysql_ic_bom.GetListAsync(a => planItemList.Contains(a.item_number) && !a.IsDeleted && a.factory_id == input.factory_id).Result;
            var monthPlan = _productionMasterPlan.GetListAsync(a => planItemList.Contains(a.ItemNumber) && !a.IsDeleted && a.factory_id == input.factory_id).Result;
            List<mes_morder> moList = new List<mes_morder>();
            List<mes_moentry> moentryList = new List<mes_moentry>();
            List<ReplenishmentWeekPlan> weekPlan = new List<ReplenishmentWeekPlan>();
            long bang_id = help.NextId();

            //获取BOM用于分解到原材料
            var boms = _ic_bom.GetListAsync(a => planItemList.Contains(a.item_number) && a.factory_id == input.factory_id).Result;
            var pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            List<mo_ic_bom> autoCreates = new List<mo_ic_bom>();
            boms.ForEach(p =>
            {
                if (!pretreatments.Where(s => s.sourceid == p.mysql_id).Any())
                {
                    autoCreates.Add(p);
                }
            });
            if (autoCreates.Any())
            {
                AutoCreateBomBill(input.company_id.ToString(), autoCreates);
                pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            }

            List<string> weeks = new List<string>();
            for (int k = 0; k < replenishmentDto.SaleFcstMonth; k++)
            {
                string kMonth = $"{DateTime.Now.AddMonths(k).Year}-{DateTime.Now.AddMonths(k).Month.ToString("00")}";
                var kTime = DateTime.Now.AddMonths(k);
                kTime = kTime.AddDays(1 - kTime.Day);//某月第一天
                for (int w = 0; w < 4; w++)
                {
                    weeks.Add($"WK{GetWeekOfYear(kTime.AddDays(7 * (w))).ToString("00")}");
                }
            }
            //更新周补货计划
            List<ReplenishmentWeekPlan> updateRopList = new List<ReplenishmentWeekPlan>();
            List<ReplenishmentWeekPlan> addRopList = new List<ReplenishmentWeekPlan>();
            for (int k = 0; k < replenishmentDto.SaleFcstMonth; k++)
            {
                //如果该10月有发布的2周生产计划，则周补货量=10月补货量-已发布的2周生产计划数量/剩余周次(2)
                string kMonth = $"{DateTime.Now.AddMonths(k+1).Year}-{DateTime.Now.AddMonths(k+1).Month.ToString("00")}";
                var monthWeekPlan = planList.Where(a => a.planmonth == kMonth).ToList();
                foreach (var item in monthWeekPlan)
                {
                    //周补货计划只计算成品，不需要到原材料
                    if(planItemList.Contains(item.number))
                    {
                        int publishedWeekCount = weekPlanList.Where(a => a.PlanMonth == kMonth && a.ItemNumber == item.number && a.ProductionStatus == "已发布" && a.DistributionChannel == item.distributionchannel).Count();
                        decimal publishedWeekQtySum = weekPlanList.Where(a => a.PlanMonth == kMonth && a.ItemNumber == item.number && a.ProductionStatus == "已发布" && a.DistributionChannel == item.distributionchannel).Sum(a => a.Qty);
                        //每次都是发布12周，每个月4周，不用判断存不存在(退市的可能没有)
                        for (int w = 0; w < 4; w++)
                        {
                            var weekItemPlan = weekPlanList.Find(a => a.PlanMonth == kMonth && a.ItemNumber == item.number && a.WeekSeq == w && a.DistributionChannel == item.distributionchannel);
                            if (weekItemPlan != null)
                            {
                                if (weekItemPlan.ProductionStatus != "已发布" && publishedWeekCount < 4)
                                {
                                    weekItemPlan.Qty = Math.Ceiling((item.montheop1.GetValueOrDefault() + item.montheop2.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                                    updateRopList.Add(weekItemPlan);
                                }
                            }
                            else if (publishedWeekCount < 4)
                            {
                                ReplenishmentWeekPlan weekItemPlanAdd = new ReplenishmentWeekPlan();
                                weekItemPlanAdd.Area = item.area;
                                weekItemPlanAdd.Week = $"WK{GetWeekOfYear(DateTime.Now.AddDays(1 - DateTime.Now.Day).AddMonths(k+1).AddDays(7 * (w))).ToString("00")}";
                                weekItemPlanAdd.DistributionChannel = item.distributionchannel;
                                weekItemPlanAdd.ProdLine = item.ProdLine;
                                weekItemPlanAdd.ProdRange = item.ProdRange;
                                weekItemPlanAdd.Model = item.model;
                                weekItemPlanAdd.ItemNumber = item.number;
                                weekItemPlanAdd.Languages = item.Languages;
                                weekItemPlanAdd.Qty = Math.Ceiling((item.montheop1.GetValueOrDefault() + item.montheop2.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                                weekItemPlanAdd.Year = DateTime.Now.AddMonths(k+1).Year;
                                weekItemPlanAdd.Month = DateTime.Now.AddMonths(k+1).Month;
                                weekItemPlanAdd.PlanMonth = $"{DateTime.Now.AddMonths(k +1).Year}-{DateTime.Now.AddMonths(k+1 ).Month.ToString("00")}"; ;
                                weekItemPlanAdd.WeekSeq = w;
                                weekItemPlanAdd.tenant_id = input.tenant_id;
                                weekItemPlanAdd.company_id = input.company_id;
                                weekItemPlanAdd.factory_id = input.factory_id;
                                weekItemPlanAdd.create_time = DateTime.Now;
                                weekItemPlanAdd.org_id = input.org_id;
                                weekItemPlanAdd.ItemStatus = "";
                                weekItemPlanAdd.IsReplenishmentModel = "Y";
                                addRopList.Add(weekItemPlanAdd);
                            }
                        }
                    }
                }
            }
            await _replenishmentWeekPlan.InsertManyAsync(addRopList);
            await _replenishmentWeekPlan.UpdateManyAsync(updateRopList);

            //更新周生产计划
            //生产线明细表
            List<ProdLineDetail> prodLines = new List<ProdLineDetail>();
            List<LineMaster> lineMasters = new List<LineMaster>();
            var routingOpList = _routingOpDetail.Select(x => x.Ufld1 == "组装" && x.MilestoneOp).ToList();
            for (int k = 0; k < replenishmentDto.SaleFcstMonth; k++)
            {
                //如果该10月有发布的2周生产计划，则周生产数量=9月补货量-已发布的2周生产计划数量/剩余周次(2)
                string kMonth = $"{DateTime.Now.AddMonths(k+1).Year}-{DateTime.Now.AddMonths(k+1).Month.ToString("00")}";
                string kPreMonth= $"{DateTime.Now.AddMonths(k ).Year}-{DateTime.Now.AddMonths(k ).Month.ToString("00")}";
                var kTime = DateTime.Now.AddMonths(k+1);
                kTime = kTime.AddDays(1 - kTime.Day);//某月第一天
                var monthWeekPlan = planList.Where(a => a.planmonth == kMonth).ToList();
                var ropList = planList.Select(t => t.number).Distinct().ToList();
                //中间件汇总，比如A成品10、11、12月都需要中间件C，B成品11、12月都需要中间件C，那么中间件C需要每个月汇总平均分到4周
                Dictionary<string, decimal?> subProductItem = new Dictionary<string, decimal?>();
                Dictionary<string, BomChildExamineDto> subProductItemModel = new Dictionary<string, BomChildExamineDto>();
                foreach (var itemSeq in ropList)
                {
                    if(shipPlanList.Select(s=>s.SAPItemNumber).ToList().Contains(itemSeq))
                    {
                        var monthPlanItem = monthPlan.Find(x => x.ItemNumber == itemSeq);
                        //瑞奇国科海王
                        var monthPlanTotal = monthWeekPlan.Where(x => x.number == itemSeq).ToList();
                        if(monthPlanTotal!=null && monthPlanTotal.Count>0)
                        {
                            var item = monthPlanTotal[0];
                            //瑞奇补货计划!Y5 + 瑞奇补货计划!Z5 + 国科补货计划!Y5 + 国科补货计划!Z5 + 海王补货计划!Y4 + 海王补货计划!Z4
                            var itemQty = monthPlanTotal.Sum(a => a.montheop1) + monthPlanTotal.Sum(a => a.montheop2);
                            //每次都是发布12周，每个月4周，不用判断存不存在(退市的可能没有)
                            int days = 15;
                            if (item.area != "国内" && item.area != "中国")
                            {
                                days = 8;
                            }
                            int publishedWeekCount = weekProductPlanList.Where(a => a.PlanMonth == kPreMonth && a.ItemNumber == item.number && a.ProductionStatus == "已发布" && a.DistributionChannel == item.distributionchannel).Count();
                            decimal publishedWeekQtySum = weekProductPlanList.Where(a => a.PlanMonth == kPreMonth && a.ItemNumber == item.number && a.ProductionStatus == "已发布" && a.DistributionChannel == item.distributionchannel).Sum(a => a.Qty);
                            for (int w = 0; w < 4; w++)
                            {
                                var weekItemPlan = weekProductPlanList.Find(a => a.PlanMonth == kPreMonth && a.ItemNumber == item.number && a.WeekSeq == w);
                                if (weekItemPlan != null)
                                {
                                    if (weekItemPlan.ProductionStatus != "已发布" && publishedWeekCount < 4)
                                    {
                                        weekItemPlan.Qty = Math.Ceiling((item.montheop1.GetValueOrDefault() + item.montheop2.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                                        updateRopList.Add(weekItemPlan);
                                    }
                                }
                                if (itemQty > 0)
                                {
                                    var bom = bomList.Find(b => b.item_number == itemSeq);
                                    var ic_item = itemList.Find(b => b.number == itemSeq);
                                    mes_morder mes_Morder = new mes_morder();
                                    mes_Morder.GenerateNewId(help.NextId());
                                    mes_Morder.morder_type = MorderEnum.JhMorder;
                                    mes_Morder.work_order_type = MorderEnum.CgMorder;
                                    mes_Morder.morder_state = "";
                                    //mes_Morder.morder_no = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "MPO", 1, "", 1)[0].NbrResult;
                                    mes_Morder.morder_no = Guid.NewGuid().ToString();
                                    mes_Morder.fms_number = ic_item.fms_number;
                                    mes_Morder.bom_number = bom.bom_number;
                                    mes_Morder.fmodel = ic_item.model;
                                    mes_Morder.moentry_startup_status = 0;
                                    mes_Morder.tenant_id = input.tenant_id;
                                    mes_Morder.factory_id = input.factory_id;
                                    mes_Morder.company_id = input.company_id;
                                    mes_Morder.org_id = input.org_id;
                                    mes_Morder.product_code = ic_item.number;
                                    mes_Morder.product_name = ic_item.name;
                                    mes_Morder.morder_date = DateTime.Now.Date.AddDays(1);
                                    mes_Morder.moentry_prd = null;
                                    mes_Morder.moentry_prdname = null;
                                    mes_Morder.moentry_wrkc = null;
                                    mes_Morder.moentry_wrkcname = null;
                                    mes_Morder.picking_qty = 0;
                                    mes_Morder.unit = ic_item.unit;
                                    mes_Morder.morder_production_number = Math.Ceiling(itemQty.GetValueOrDefault() / 4);
                                    mes_Morder.need_number = Math.Ceiling(itemQty.GetValueOrDefault() / 4);
                                    //成品半成品取周一为入库时间开始往前推
                                    mes_Morder.moentry_sys_stime = kTime.AddDays(7 * w - ProductTime(routingOps, ic_item.number, input.factory_id.ToString(), mes_Morder.need_number.GetValueOrDefault()) - days);
                                    mes_Morder.moentry_sys_etime = kTime.AddDays(7 * w - days);
                                    mes_Morder.remaining_number = 0;
                                    mes_Morder.create_time = DateTime.Now;
                                    mes_Morder.bang_id = bang_id;
                                    //生成工单子表数据
                                    mes_moentry mes_Moentry = new mes_moentry();
                                    mes_Moentry.GenerateNewId(help.NextId());
                                    mes_Moentry.moentry_moid = mes_Morder.Id;
                                    mes_Moentry.moentry_mono = mes_Morder.morder_no;
                                    mes_Moentry.unit = ic_item.unit;
                                    mes_Moentry.morder_production_number = Math.Ceiling(itemQty.GetValueOrDefault() / 4); ;
                                    mes_Moentry.need_number = Math.Ceiling(itemQty.GetValueOrDefault() / 4); ;
                                    mes_Moentry.remaining_number = 0;
                                    mes_Moentry.tenant_id = input.tenant_id;
                                    mes_Moentry.factory_id = input.factory_id;
                                    mes_Moentry.company_id = input.company_id;
                                    mes_Moentry.org_id = input.org_id;
                                    mes_Moentry.create_time = DateTime.Now;
                                    mes_Moentry.bang_id = bang_id;

                                    ReplenishmentWeekPlan weekItem = new ReplenishmentWeekPlan();
                                    weekItem.Priority = 1;
                                    weekItem.Area = item.area;
                                    weekItem.PlanStartDate = mes_Morder.moentry_sys_stime.GetValueOrDefault();
                                    weekItem.Week = $"WK{GetWeekOfYear(mes_Morder.moentry_sys_stime.Value).ToString("00")}";
                                    //weekItem.OrderNO = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "WO", 1, "", 1)[0].NbrResult;
                                    weekItem.OrderNO = Guid.NewGuid().ToString();
                                    weekItem.ProductionOrder = mes_Morder.morder_no;
                                    weekItem.SAPOrderNO = "";
                                    weekItem.OrderType = "量产";
                                    weekItem.ProductionBatch = "";
                                    weekItem.ProductionStatus = "";
                                    weekItem.ProdLine = item.ProdLine;
                                    weekItem.ProdRange = item.ProdRange;
                                    weekItem.Line = monthPlanItem?.WorkshopLine;
                                    weekItem.ItemNumber = item.number;
                                    weekItem.Model = item.model;
                                    weekItem.Languages = item.Languages;
                                    weekItem.Qty = mes_Morder.morder_production_number.Value;
                                    weekItem.ItemStatus = "";
                                    weekItem.PlanKittingDate = DateTime.Now;
                                    weekItem.Year = DateTime.Now.AddMonths(k).Year;
                                    weekItem.Month = DateTime.Now.AddMonths(k).Month;
                                    weekItem.PlanMonth = kMonth;
                                    weekItem.WeekSeq = w;
                                    weekItem.tenant_id = input.tenant_id;
                                    weekItem.factory_id = input.factory_id;
                                    weekItem.company_id = input.company_id;
                                    weekItem.org_id = input.org_id;
                                    weekItem.create_time = DateTime.Now;
                                    weekItem.DistributionChannel = item.distributionchannel;
                                    weekItem.IsReplenishmentModel = "N";
                                    if (item.area == "国内" || item.area == "中国")
                                    {
                                        weekItem.SterilizationDate = mes_Morder.moentry_sys_etime.Value;
                                        weekItem.InStockDate = mes_Morder.moentry_sys_etime.Value.AddDays(15);
                                    }
                                    else
                                    {
                                        weekItem.SterilizationDate = mes_Morder.moentry_sys_etime.Value;
                                        weekItem.InStockDate = mes_Morder.moentry_sys_etime.Value.AddDays(8);
                                    }
                                    weekItem.AssembleHours = 0;
                                    weekItem.HeatSealHours = 0;
                                    weekItem.PackageHours = 0;
                                    weekItem.TotalHours = 0;
                                    weekPlan.Add(weekItem);
                                    moList.Add(mes_Morder);
                                    moentryList.Add(mes_Moentry);
                                }
                            }
                            var planBOM = boms.Find(b => b.item_number == itemSeq);
                            var pretreament = pretreatments.Where(c => c.sourceid == planBOM.mysql_id).ToList();
                            var returnlist = ObjectMapper.Map<List<b_bom_pretreatment>, List<BomChildExamineDto>>(pretreament);
                            returnlist = returnlist.OrderBy(s => s.num_order).ToList();
                            var level1Dto = returnlist[0];
                            level1Dto.needCount = itemQty.GetValueOrDefault();
                            CaclMaterialShortage(returnlist);
                            foreach (var r in returnlist)
                            {
                                if (r.item_number != itemSeq && r.erp_cls == 1 && !string.IsNullOrEmpty(r.bom_number))
                                {
                                    if (subProductItem.ContainsKey(r.item_number))
                                    {
                                        subProductItem[r.item_number] += r.needCount;
                                    }
                                    else
                                    {
                                        subProductItem.Add(r.item_number, r.needCount);
                                        subProductItemModel.Add(r.item_number, r);
                                    }
                                }
                            }
                        }
                    }
                }
                if(prodLines.Count==0)
                {
                    prodLines=_prodLineDetail.Select(p => subProductItem.Keys.Contains(p.Part) && p.Domain == input.factory_id.ToString() && p.IsActive && routingOpList.Select(m => m.Op).Contains(p.Op)).OrderBy(x => x.Sequence).ToList();
                }
                if(lineMasters.Count==0)
                {
                    lineMasters = _lineMaster.Select(p => prodLines.Select(a => a.Line).Contains(p.Line) && p.Domain == input.factory_id.ToString() && p.IsActive).ToList();
                }
                var middleItemList=_itemMaster.Select(a => subProductItem.Keys.Contains(a.ItemNum) && a.Domain == input.factory_id.ToString());
                foreach (var key in subProductItem.Keys)
                {
                    var itemQty = subProductItem[key];
                    var middleItem = middleItemList.Find(m => m.ItemNum == key).MinOrdSales;
                    if (middleItem == 0)
                        middleItem = 10000;
                    if (itemQty< middleItem)
                    {
                        itemQty = middleItem;
                    }else if(middleItem>0)
                    {
                        itemQty = Math.Ceiling(Math.Ceiling(itemQty.GetValueOrDefault()/ middleItem) * middleItem);
                    } 
                    
                    int publishedWeekCount = weekProductPlanList.Where(a => a.PlanMonth == kPreMonth && a.ItemNumber == key && a.ProductionStatus == "已发布").Count();
                    decimal publishedWeekQtySum = weekProductPlanList.Where(a => a.PlanMonth == kPreMonth && a.ItemNumber == key && a.ProductionStatus == "已发布").Sum(a => a.Qty);
                    //如果平均每周的需求大于经济批量直接均分
                    if(publishedWeekCount<4 && itemQty/(4-publishedWeekCount)>= middleItem)
                    {
                        for(int w= publishedWeekCount;w<4;w++)
                        {
                            mes_morder mes_Morder = new mes_morder();
                            mes_Morder.GenerateNewId(help.NextId());
                            mes_Morder.morder_type = MorderEnum.JhMorder;
                            mes_Morder.work_order_type = MorderEnum.CgMorder;
                            mes_Morder.morder_state = "";
                            //mes_Morder.morder_no = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "MPO", 1, "", 1)[0].NbrResult;
                            mes_Morder.morder_no = Guid.NewGuid().ToString();
                            mes_Morder.fms_number = "";
                            mes_Morder.bom_number = subProductItemModel[key].bom_number;
                            mes_Morder.fmodel = subProductItemModel[key].model;
                            mes_Morder.moentry_startup_status = 0;
                            mes_Morder.tenant_id = input.tenant_id;
                            mes_Morder.factory_id = input.factory_id;
                            mes_Morder.company_id = input.company_id;
                            mes_Morder.org_id = input.org_id;
                            mes_Morder.product_code = subProductItemModel[key].item_number;
                            mes_Morder.product_name = subProductItemModel[key].item_name;
                            mes_Morder.morder_date = DateTime.Now.Date.AddDays(1);
                            mes_Morder.moentry_prd = null;
                            mes_Morder.moentry_prdname = null;
                            mes_Morder.moentry_wrkc = null;
                            mes_Morder.moentry_wrkcname = null;
                            mes_Morder.picking_qty = 0;
                            mes_Morder.unit = subProductItemModel[key].unit;
                            mes_Morder.morder_production_number = Math.Ceiling((itemQty.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                            mes_Morder.need_number = Math.Ceiling((itemQty.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                            //成品半成品取周一为入库时间开始往前推
                            mes_Morder.moentry_sys_stime = kTime.AddDays(7 * w - ProductTime(routingOps, subProductItemModel[key].item_number, input.factory_id.ToString(), mes_Morder.need_number.GetValueOrDefault()));
                            mes_Morder.moentry_sys_etime = kTime.AddDays(7 * w);
                            mes_Morder.remaining_number = 0;
                            mes_Morder.create_time = DateTime.Now;
                            mes_Morder.bang_id = bang_id;
                            //生成工单子表数据
                            mes_moentry mes_Moentry = new mes_moentry();
                            mes_Moentry.GenerateNewId(help.NextId());
                            mes_Moentry.moentry_moid = mes_Morder.Id;
                            mes_Moentry.moentry_mono = mes_Morder.morder_no;
                            mes_Moentry.unit = subProductItemModel[key].unit;
                            mes_Moentry.morder_production_number = Math.Ceiling((itemQty.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                            mes_Moentry.need_number = Math.Ceiling((itemQty.GetValueOrDefault() - publishedWeekQtySum) / (4 - publishedWeekCount));
                            mes_Moentry.remaining_number = 0;
                            mes_Moentry.tenant_id = input.tenant_id;
                            mes_Moentry.factory_id = input.factory_id;
                            mes_Moentry.company_id = input.company_id;
                            mes_Moentry.org_id = input.org_id;
                            mes_Moentry.create_time = DateTime.Now;
                            mes_Moentry.bang_id = bang_id;

                            var prodLine = prodLines.Where(x => x.Part == key).OrderBy(x => x.Sequence).FirstOrDefault();
                            ReplenishmentWeekPlan weekItem = new ReplenishmentWeekPlan();
                            weekItem.Priority = 1;
                            weekItem.Area = "";
                            weekItem.PlanStartDate = mes_Morder.moentry_sys_stime.GetValueOrDefault();
                            weekItem.Week = $"WK{GetWeekOfYear(mes_Morder.moentry_sys_stime.Value).ToString("00")}";
                            //weekItem.OrderNO = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "WO", 1, "", 1)[0].NbrResult;
                            weekItem.OrderNO = Guid.NewGuid().ToString();
                            weekItem.ProductionOrder = mes_Morder.morder_no;
                            weekItem.SAPOrderNO = "";
                            weekItem.OrderType = "量产";
                            weekItem.ProductionBatch = "";
                            weekItem.ProductionStatus = "";
                            weekItem.ProdLine = "";
                            weekItem.ProdRange = "";
                            if (prodLine != null && lineMasters.Find(b => b.Line == prodLine.Line) != null)
                            {
                                weekItem.Line = lineMasters.Find(b => b.Line == prodLine.Line).Describe;
                            }
                            else
                            {
                                weekItem.Line = "";
                            }

                            weekItem.ItemNumber = key;
                            weekItem.Model = subProductItemModel[key].model;
                            weekItem.Languages = "";
                            weekItem.Qty = mes_Morder.morder_production_number.Value;
                            weekItem.ItemStatus = "";
                            weekItem.PlanKittingDate = DateTime.Now;
                            weekItem.Year = DateTime.Now.AddMonths(k).Year;
                            weekItem.Month = DateTime.Now.AddMonths(k).Month;
                            weekItem.PlanMonth = kMonth;
                            weekItem.WeekSeq = w;
                            weekItem.tenant_id = input.tenant_id;
                            weekItem.factory_id = input.factory_id;
                            weekItem.company_id = input.company_id;
                            weekItem.org_id = input.org_id;
                            weekItem.create_time = DateTime.Now;
                            weekItem.DistributionChannel = "瑞奇";
                            weekItem.IsReplenishmentModel = "N";
                            weekItem.InStockDate = mes_Morder.moentry_sys_etime.Value;
                            weekItem.AssembleHours = 0;
                            weekItem.HeatSealHours = 0;
                            weekItem.PackageHours = 0;
                            weekItem.TotalHours = 0;
                            weekPlan.Add(weekItem);
                            moList.Add(mes_Morder);
                            moentryList.Add(mes_Moentry);
                        }
                    }else if(publishedWeekCount < 4 && itemQty / (4 - publishedWeekCount) < middleItem)//不够的话就按顺序排
                    {
                        for (int w = publishedWeekCount; w < 4; w++)
                        {
                            if(itemQty>0)
                            {
                                mes_morder mes_Morder = new mes_morder();
                                mes_Morder.GenerateNewId(help.NextId());
                                mes_Morder.morder_type = MorderEnum.JhMorder;
                                mes_Morder.work_order_type = MorderEnum.CgMorder;
                                mes_Morder.morder_state = "";
                                //mes_Morder.morder_no = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "MPO", 1, "", 1)[0].NbrResult;
                                mes_Morder.morder_no = Guid.NewGuid().ToString();
                                mes_Morder.fms_number = "";
                                mes_Morder.bom_number = subProductItemModel[key].bom_number;
                                mes_Morder.fmodel = subProductItemModel[key].model;
                                mes_Morder.moentry_startup_status = 0;
                                mes_Morder.tenant_id = input.tenant_id;
                                mes_Morder.factory_id = input.factory_id;
                                mes_Morder.company_id = input.company_id;
                                mes_Morder.org_id = input.org_id;
                                mes_Morder.product_code = subProductItemModel[key].item_number;
                                mes_Morder.product_name = subProductItemModel[key].item_name;
                                mes_Morder.morder_date = DateTime.Now.Date.AddDays(1);
                                mes_Morder.moentry_prd = null;
                                mes_Morder.moentry_prdname = null;
                                mes_Morder.moentry_wrkc = null;
                                mes_Morder.moentry_wrkcname = null;
                                mes_Morder.picking_qty = 0;
                                mes_Morder.unit = subProductItemModel[key].unit;
                                mes_Morder.morder_production_number =middleItem;
                                mes_Morder.need_number = middleItem;
                                //成品半成品取周一为入库时间开始往前推
                                mes_Morder.moentry_sys_stime = kTime.AddDays(7 * w - ProductTime(routingOps, subProductItemModel[key].item_number, input.factory_id.ToString(), mes_Morder.need_number.GetValueOrDefault()));
                                mes_Morder.moentry_sys_etime = kTime.AddDays(7 * w);
                                mes_Morder.remaining_number = 0;
                                mes_Morder.create_time = DateTime.Now;
                                mes_Morder.bang_id = bang_id;
                                //生成工单子表数据
                                mes_moentry mes_Moentry = new mes_moentry();
                                mes_Moentry.GenerateNewId(help.NextId());
                                mes_Moentry.moentry_moid = mes_Morder.Id;
                                mes_Moentry.moentry_mono = mes_Morder.morder_no;
                                mes_Moentry.unit = subProductItemModel[key].unit;
                                mes_Moentry.morder_production_number = middleItem;
                                mes_Moentry.need_number = middleItem;
                                mes_Moentry.remaining_number = 0;
                                mes_Moentry.tenant_id = input.tenant_id;
                                mes_Moentry.factory_id = input.factory_id;
                                mes_Moentry.company_id = input.company_id;
                                mes_Moentry.org_id = input.org_id;
                                mes_Moentry.create_time = DateTime.Now;
                                mes_Moentry.bang_id = bang_id;

                                var prodLine = prodLines.Where(x => x.Part == key).OrderBy(x => x.Sequence).FirstOrDefault();
                                ReplenishmentWeekPlan weekItem = new ReplenishmentWeekPlan();
                                weekItem.Priority = 1;
                                weekItem.Area = "";
                                weekItem.PlanStartDate = mes_Morder.moentry_sys_stime.GetValueOrDefault();
                                weekItem.Week = $"WK{GetWeekOfYear(mes_Morder.moentry_sys_stime.Value).ToString("00")}";
                                //weekItem.OrderNO = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "WO", 1, "", 1)[0].NbrResult;
                                weekItem.OrderNO = Guid.NewGuid().ToString();
                                weekItem.ProductionOrder = mes_Morder.morder_no;
                                weekItem.SAPOrderNO = "";
                                weekItem.OrderType = "量产";
                                weekItem.ProductionBatch = "";
                                weekItem.ProductionStatus = "";
                                weekItem.ProdLine = "";
                                weekItem.ProdRange = "";
                                if (prodLine != null && lineMasters.Find(b => b.Line == prodLine.Line) != null)
                                {
                                    weekItem.Line = lineMasters.Find(b => b.Line == prodLine.Line).Describe;
                                }
                                else
                                {
                                    weekItem.Line = "";
                                }

                                weekItem.ItemNumber = key;
                                weekItem.Model = subProductItemModel[key].model;
                                weekItem.Languages = "";
                                weekItem.Qty = mes_Morder.morder_production_number.Value;
                                weekItem.ItemStatus = "";
                                weekItem.PlanKittingDate = DateTime.Now;
                                weekItem.Year = DateTime.Now.AddMonths(k).Year;
                                weekItem.Month = DateTime.Now.AddMonths(k).Month;
                                weekItem.PlanMonth = kMonth;
                                weekItem.WeekSeq = w;
                                weekItem.tenant_id = input.tenant_id;
                                weekItem.factory_id = input.factory_id;
                                weekItem.company_id = input.company_id;
                                weekItem.org_id = input.org_id;
                                weekItem.create_time = DateTime.Now;
                                weekItem.DistributionChannel = "瑞奇";
                                weekItem.IsReplenishmentModel = "N";
                                weekItem.InStockDate = mes_Morder.moentry_sys_etime.Value;
                                weekItem.AssembleHours = 0;
                                weekItem.HeatSealHours = 0;
                                weekItem.PackageHours = 0;
                                weekItem.TotalHours = 0;
                                weekPlan.Add(weekItem);
                                moList.Add(mes_Morder);
                                moentryList.Add(mes_Moentry);
                                itemQty -= middleItem;
                            }
                        }
                    }
                }
            }
            var morder_noList = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "M5", moList.Count, "", 1);
            var OrderNOList= _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "MPO", moList.Count, "", 1);
            for(int i=0;i< moList.Count;i++)
            {
                moList[i].morder_no = morder_noList[i].NbrResult;
                moentryList[i].moentry_mono = morder_noList[i].NbrResult;
                weekPlan[i].ProductionOrder = morder_noList[i].NbrResult;
                weekPlan[i].OrderNO = OrderNOList[i].NbrResult;
            }
            await PlanOrderResourceCheck(moList, moentryList, bang_id, input);

            var examine_resultList = _mysql_examine_result.GetListAsync(a => a.bangid == bang_id).Result;
            await _mysql_mes_morder.InsertManyAsync(moList);
            await _mysql_mes_moentry.InsertManyAsync(moentryList);

            //批量保存 后期考虑子工单
            List<WorkOrdMaster> workOrdSave = new List<WorkOrdMaster>();
            List<WorkOrdRouting> workOrdRoutingSave = new List<WorkOrdRouting>();
            List<WorkOrdDetail> workOrdDetails = new List<WorkOrdDetail>();
            if (moList.Any())
            {
                moList.ForEach(s => { s.create_time = DateTime.Now; });
                List<b_bom_child_examine> childExamineList = _mysql_bom_child_examine.GetListAsync(c => examine_resultList.Select(x => x.Id).Contains(c.examine_id.GetValueOrDefault())).Result;
                //同步工单
                CreateWorkOrdDates(moList, routingOps, workOrdSave, workOrdRoutingSave, workOrdDetails, examine_resultList, childExamineList);
            }

            if (workOrdSave.Any())
            {
                workOrdSave = CalcPriority(workOrdSave, input.factory_id.ToString());
                _workOrdMaster.Insert(workOrdSave);
            }
            var DBworkOrdList = _workOrdMaster.Select(a => workOrdSave.Count>0&& a.Domain == workOrdSave[0].Domain && workOrdSave.Select(c => c.WorkOrd).Contains(a.WorkOrd));
            if (workOrdRoutingSave.Any())
            {
                workOrdRoutingSave.ForEach(c =>
                {
                    c.WorkOrdMasterRecID = DBworkOrdList.Where(a => a.WorkOrd == c.WorkOrd).First().RecID;
                });
                _workOrdRouting.Insert(workOrdRoutingSave);
            }
            if (workOrdDetails.Any())
            {
                workOrdDetails.ForEach(c =>
                {
                    c.WorkOrdMasterRecID = DBworkOrdList.Where(a => a.WorkOrd == c.WorkOrd).First().RecID;
                });
                _workOrdDetail.Insert(workOrdDetails);
            }

            weekPlan.ForEach(a =>
            {
                if (a.IsReplenishmentModel == "N")
                {
                    var moItem = examine_resultList.Find(b => b.morder_no == a.ProductionOrder);
                    List<RoutingOpDetail> routingOp = routingOps.Where(x => x.RoutingCode == a.ItemNumber).ToList();
                    //组装标准工时
                    var Assembly = routingOp.Where(x => x.Ufld1 == "组装" && x.MilestoneOp).FirstOrDefault();
                    //热封标准工时
                    var HeatSealing = routingOp.Where(x => x.Ufld1 == "热封" && x.MilestoneOp).FirstOrDefault();
                    //包装标准工时
                    var Packaging = routingOp.Where(x => x.Descr == "包装" && x.MilestoneOp).FirstOrDefault();
                    if (moItem != null && moItem.kitting_times < a.PlanStartDate)
                    {
                        a.ItemStatus = "齐套";
                        a.PlanKittingDate = moItem.kitting_times;
                        a.AssembleHours = Assembly == null ? 0 : Assembly.RunTime * a.Qty;
                        a.HeatSealHours = HeatSealing == null ? 0 : HeatSealing.RunTime * a.Qty;
                        a.PackageHours = Packaging == null ? 0 : Packaging.RunTime * a.Qty;
                        a.TotalHours = a.AssembleHours + a.HeatSealHours + a.PackageHours;
                    }
                    else
                    {
                        a.ItemStatus = "欠料";
                        a.PlanKittingDate = moItem.kitting_times;
                        a.AssembleHours = Assembly == null ? 0 : Assembly.RunTime * a.Qty;
                        a.HeatSealHours = HeatSealing == null ? 0 : HeatSealing.RunTime * a.Qty;
                        a.PackageHours = Packaging == null ? 0 : Packaging.RunTime * a.Qty;
                        a.TotalHours = a.AssembleHours + a.HeatSealHours + a.PackageHours;
                    }
                    var workOrd = workOrdSave.Find(b => b.WorkOrd == a.ProductionOrder);
                    if (workOrd != null)
                    {
                        a.Priority = workOrd.Priority;
                    }
                }
            });
            await _replenishmentWeekPlan.InsertManyAsync(weekPlan);
            return "OK";
        }

        /// <summary>
        /// 根据标准工艺获取生产时长（天）
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public int ProductTime(List<RoutingOpDetail> routingOps, string ItemNum,string Domain,decimal QtyOrd)
        {
            var allOps = routingOps.Where(s => s.RoutingCode ==ItemNum && s.Domain ==Domain).ToList();

            if (allOps.Any())
            {
                decimal maxRt = allOps.Max(s => s.RunTime);
                decimal sumRt = allOps.Sum(s => s.RunTime);
                decimal totalTime = (QtyOrd - 1) * maxRt + sumRt;//总计生产小时
                return (int)(Math.Ceiling(totalTime / 8));
            }
            return 1;
        }

        /// <summary>
        /// 发布周计划
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> PublishWeekPlan(InputDto input)
        {
            DateTime nextWeekMonday = getPreWeekStartTime().AddDays(14);
            DateTime next2WeekMonday = getPreWeekStartTime().AddDays(28);
            var weekPlan = _replenishmentWeekPlan.GetListAsync(a => a.PlanStartDate >= nextWeekMonday && a.PlanStartDate < next2WeekMonday && a.IsReplenishmentModel=="N").Result.OrderBy(a=>a.Priority).ToList();
            List<WorkOrdMaster> workMasters = _workOrdMaster.Select(a => weekPlan.Select(s=>s.ItemNumber).Contains(a.ItemNum) && weekPlan.Select(p=>p.ProductionOrder).Contains(a.WorkOrd) && a.Domain == input.factory_id.ToString());
            List<mes_morder> mes_Morders = _mysql_mes_morder.GetListAsync(a => workMasters.Select(b => b.WorkOrd).ToList().Contains(a.morder_no) && a.factory_id == input.factory_id).Result;
            decimal priority = 1;
            for(int i=0;i<weekPlan.Count;i++)
            {
                weekPlan[i].ProductionStatus = "已发布";
                weekPlan[i].Priority = priority;
                workMasters.ForEach(b =>
                {
                    if (b.ItemNum == weekPlan[i].ItemNumber && b.WorkOrd == weekPlan[i].ProductionOrder)
                    {
                        b.Priority = priority;
                        b.Status = "p";
                    }
                });
                mes_Morders.ForEach(c =>
                {
                    c.morder_state = MorderEnum.Initial_state;
                });
                priority++;
            }
            _workOrdMaster.Update(workMasters);
            await _mysql_mes_morder.UpdateManyAsync(mes_Morders);
            await _replenishmentWeekPlan.UpdateManyAsync(weekPlan);
            return "OK";
        }

        /// <summary>
        /// 每天补货
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> CalcDayPlan(InputDto input)
        {
            input.year = DateTime.Now.Year;
            input.month = DateTime.Now.Month;
            ReplenishmentDto replenishmentDto = GetROPParam(input.factory_id.ToString());
            //DOP运行资源检查每个成品和半成品SKU的可用库存，当可用库存 <= 修正后ROP时，自动生成月度计划订单（MPlan order，MPO48年月日3位流水号）= EOP；可用库存为没有被其他SO和PO占用的（合格成品或半成品库存 + WIP）；
            var ropModelList = _replenishmentROPWeekPlan.GetListAsync(a => a.planmonth==$"{DateTime.Now.Year}-{DateTime.Now.Month.ToString("00")}" && a.erp_cls==1 && a.distributionchannel=="瑞奇" && a.factory_id==input.factory_id  && !a.IsDeleted).Result;
            List<string> planItemList = ropModelList?.Select(a => a.number).Distinct().ToList();
            var itemList = _mysql_ic_item.GetListAsync(a => planItemList.Contains(a.number) && !a.IsDeleted).Result;
            //获取BOM用于分解到原材料
            var boms = _ic_bom.GetListAsync(a => ropModelList.Select(p => p.number).ToList().Contains(a.item_number) && a.factory_id == input.factory_id).Result;
            var pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            List<mo_ic_bom> autoCreates = new List<mo_ic_bom>();
            boms.ForEach(p =>
            {
                if (!pretreatments.Where(s => s.sourceid == p.mysql_id).Any())
                {
                    autoCreates.Add(p);
                }
            });
            if (autoCreates.Any())
            {
                AutoCreateBomBill(input.company_id.ToString(), autoCreates);
                pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            }

            var itemStock = CalcStock(ropModelList.Select(a => a.number).ToList(), input);
            var bomList = _ic_bom.GetListAsync(a => ropModelList.Select(a => a.number).ToList().Contains(a.item_number) && !a.IsDeleted && a.factory_id == input.factory_id).Result;
            List<mes_morder> moList = new List<mes_morder>();
            List<mes_moentry> moentryList = new List<mes_moentry>();

            List<string> planMonthList = new List<string>();
            for (int j = 0; j < replenishmentDto.SaleFcstMonth+3; j++)
            {
                string itemMonth = $"{DateTime.Now.AddMonths(j).Year}-{DateTime.Now.AddMonths(j).Month.ToString("00")}";
                planMonthList.Add(itemMonth);
            }
            planMonthList.Sort();
            //获取周生产计划
            var WeekPlanList=_replenishmentWeekPlan.GetListAsync(a => ropModelList.Select(b => b.number).ToList().Contains(a.ItemNumber) && a.IsReplenishmentModel == "N" && planMonthList.Contains(a.PlanMonth)).Result;
            var workOrdMasterList=_workOrdMaster.Select(s => WeekPlanList.Select(a => a.ProductionOrder).ToList().Contains(s.WorkOrd) && s.Domain == input.factory_id.ToString());
            var workOrdDetailList = _workOrdDetail.Select(s => WeekPlanList.Select(a => a.ProductionOrder).ToList().Contains(s.WorkOrd) && s.Domain == input.factory_id.ToString());
            var workOrdRoutingList = _workOrdRouting.Select(s => WeekPlanList.Select(a => a.ProductionOrder).ToList().Contains(s.WorkOrd) && s.Domain == input.factory_id.ToString());
            var mesmorderList = _mysql_mes_morder.GetListAsync(s=>WeekPlanList.Select(a => a.ProductionOrder).ToList().Contains(s.morder_no) && s.factory_id == input.factory_id).Result;
            var mesmorderEntryList = _mysql_mes_moentry.GetListAsync(s => WeekPlanList.Select(a => a.ProductionOrder).ToList().Contains(s.moentry_mono) && s.factory_id == input.factory_id).Result;
            
            //扣减需要删除周生产计划
            List<ReplenishmentWeekPlan> deleteList=new List<ReplenishmentWeekPlan>();
            //扣减需要更新周生产计划
            List<ReplenishmentWeekPlan> updateList = new List<ReplenishmentWeekPlan>();
            //减货
            ropModelList.ForEach(a => {
                //超出最高库存，优先扣减日期最近未发布的周生计划数量和对应的计划工单的数量
                if(itemStock.First(c => c.ItemNumber == a.number).Qty>a.max_stock_level)
                {
                    decimal? Qty = itemStock.First(c => c.ItemNumber == a.number).Qty - a.max_stock_level;
                    var itemWeekPlan=WeekPlanList.FindAll(b => b.ItemNumber == a.number);
                    //如果没找到周生成计划，那没法扣减，理论上不会出现这种数据场景
                    if(itemWeekPlan!=null&& itemWeekPlan.Count>0)
                    {
                        itemWeekPlan.OrderBy(a => a.Year).ThenBy(b => b.Month).ThenBy(c => c.Week).ThenBy(d => d.WeekSeq);
                        for (int i = 0; i < itemWeekPlan.Count; i++)
                        {
                            if (itemWeekPlan[i].ProductionStatus!="已发布")
                            {
                                if(itemWeekPlan[i].Qty<=Qty)
                                {
                                    deleteList.Add(itemWeekPlan[i]);
                                    Qty =Qty-itemWeekPlan[i].Qty;
                                }else
                                {
                                    itemWeekPlan[i].Qty = itemWeekPlan[i].Qty - Qty.GetValueOrDefault();
                                    updateList.Add(itemWeekPlan[i]);
                                    break;
                                }
                            }
                        }
                    }
                }
            });

            if(deleteList.Count>0)
            {
               await _replenishmentWeekPlan.DeleteManyAsync(deleteList);
               _workOrdMaster.Delete(workOrdMasterList.Where(a => deleteList.Select(b => b.ProductionOrder).ToList().Contains(a.WorkOrd)).ToList());
               _workOrdDetail.Delete(workOrdDetailList.Where(a => deleteList.Select(b => b.ProductionOrder).ToList().Contains(a.WorkOrd)).ToList());
               _workOrdRouting.Delete(workOrdRoutingList.Where(a => deleteList.Select(b => b.ProductionOrder).ToList().Contains(a.WorkOrd)).ToList());
               await _mysql_mes_morder.DeleteManyAsync(mesmorderList.Where(a => deleteList.Select(b => b.ProductionOrder).ToList().Contains(a.morder_no)).ToList());
               await _mysql_mes_moentry.DeleteManyAsync(mesmorderEntryList.Where(a => deleteList.Select(b => b.ProductionOrder).ToList().Contains(a.moentry_mono)).ToList());
            }
            if (updateList.Count > 0)
            {
                await _replenishmentWeekPlan.UpdateManyAsync(updateList);
                List<WorkOrdMaster> itemUpdate = new List<WorkOrdMaster>();
                List<WorkOrdDetail> itemDetailUpdate = new List<WorkOrdDetail>();
                List<WorkOrdRouting> itemRoutingUpdate = new List<WorkOrdRouting>();
                List<mes_morder> itemMesmorderList = new List<mes_morder>();
                List<mes_moentry> itemMesmorderEntryList = new List<mes_moentry>();
                foreach (var item in updateList)
                {
                    var workItem = workOrdMasterList.Find(a => a.ItemNum == item.ItemNumber && a.WorkOrd == item.ProductionOrder);
                    workItem.QtyOrded = item.Qty;
                    var workDetailItem = workOrdDetailList.Find(a => a.ItemNum == item.ItemNumber && a.WorkOrd == item.ProductionOrder);
                    workDetailItem.QtyRequired= item.Qty;
                    var workOrderItem = mesmorderList.Find(a => a.product_code == item.ItemNumber && a.morder_no == item.ProductionOrder);
                    workOrderItem.need_number = item.Qty;
                    workOrderItem.morder_production_number = item.Qty;
                    var workOrdEntryItem = mesmorderEntryList.Find(a => a.moentry_mono == item.ProductionOrder);
                    workOrdEntryItem.need_number = item.Qty;
                    workOrdEntryItem.morder_production_number = item.Qty;
                    itemUpdate.Add(workItem);
                    itemDetailUpdate.Add(workDetailItem);
                    itemMesmorderList.Add(workOrderItem);
                    itemMesmorderEntryList.Add(workOrdEntryItem);

                    var planBOM = boms.Find(b => b.item_number == item.ItemNumber);
                    var pretreament = pretreatments.Where(c => c.sourceid == planBOM.mysql_id).ToList();
                    var returnlist = ObjectMapper.Map<List<b_bom_pretreatment>, List<BomChildExamineDto>>(pretreament);
                    returnlist = returnlist.OrderBy(s => s.num_order).ToList();
                    var level1Dto = returnlist[0];
                    level1Dto.qty = item.Qty;
                    CaclMaterialShortage(returnlist);
                    foreach (var child in returnlist)
                    {
                        var itemWorkOrdRoutingList = workOrdRoutingList.FindAll(w => w.WorkOrd == item.ProductionOrder);
                        if (itemWorkOrdRoutingList != null && itemWorkOrdRoutingList.Count > 0)
                        {
                            foreach (var r in itemWorkOrdRoutingList)
                            {
                                if (r.ItemNum == child.item_number)
                                {
                                    r.QtyOrded = child.needCount;
                                    itemRoutingUpdate.Add(r);
                                }
                            }
                        }
                    }
                }
                _workOrdMaster.Update(itemUpdate);
                _workOrdDetail.Update(itemDetailUpdate);
                _workOrdRouting.Update(itemRoutingUpdate);
                await _mysql_mes_morder.UpdateManyAsync(itemMesmorderList);
                await _mysql_mes_moentry.UpdateManyAsync(itemMesmorderEntryList);
            }

            //补货
            List<ReplenishmentWeekPlan> weekPlanAdd = new List<ReplenishmentWeekPlan>();
            List<RoutingOpDetail> routingOps = _routingOpDetail.Select(p => planItemList.Contains(p.RoutingCode) && p.Domain == input.factory_id.ToString() && p.IsActive);
            long bang_id = help.NextId();
            ropModelList.ForEach(a => {
                //低于安全库存，优先调整日期最近未发布的周生计划数量和对应的计划工单的数量
                if (itemStock.First(c => c.ItemNumber == a.number).Qty < a.security_stock)
                {
                    decimal? Qty =a.max_stock_level- itemStock.First(c => c.ItemNumber == a.number).Qty;
                    var itemWeekPlan = WeekPlanList.FindAll(b => b.ItemNumber == a.number);
                    //如果没找到周生成计划，那没法扣减，理论上不会出现这种数据场景
                    if (itemWeekPlan != null && itemWeekPlan.Count > 0)
                    {
                        itemWeekPlan.OrderBy(a => a.Year).ThenBy(b => b.Month).ThenBy(c => c.Week).ThenBy(d => d.WeekSeq);
                        for (int i = 0; i < itemWeekPlan.Count; i++)
                        {
                            if (itemWeekPlan[i].ProductionStatus != "已发布")
                            {
                                itemWeekPlan[i].Qty = itemWeekPlan[i].Qty + Qty.GetValueOrDefault();
                                weekPlanAdd.Add(itemWeekPlan[i]);
                            }
                        }
                    }
                }

            });
            if (weekPlanAdd.Count > 0)
            {
                await _replenishmentWeekPlan.UpdateManyAsync(weekPlanAdd);
                List<WorkOrdMaster> itemUpdate = new List<WorkOrdMaster>();
                List<WorkOrdDetail> itemDetailUpdate = new List<WorkOrdDetail>();
                List<WorkOrdRouting> itemRoutingUpdate = new List<WorkOrdRouting>();
                List<mes_morder> itemMesmorderList = new List<mes_morder>();
                List<mes_moentry> itemMesmorderEntryList = new List<mes_moentry>();
                foreach (var item in weekPlanAdd)
                {
                    var workItem = workOrdMasterList.Find(a => a.ItemNum == item.ItemNumber && a.WorkOrd == item.ProductionOrder);
                    workItem.QtyOrded = item.Qty;
                    var workDetailItem = workOrdDetailList.Find(a => a.ItemNum == item.ItemNumber && a.WorkOrd == item.ProductionOrder);
                    workDetailItem.QtyRequired = item.Qty;
                    var workOrderItem = mesmorderList.Find(a => a.product_code == item.ItemNumber && a.morder_no == item.ProductionOrder);
                    workOrderItem.need_number = item.Qty;
                    workOrderItem.morder_production_number = item.Qty;
                    var workOrdEntryItem = mesmorderEntryList.Find(a => a.moentry_mono == item.ProductionOrder);
                    workOrdEntryItem.need_number = item.Qty;
                    workOrdEntryItem.morder_production_number = item.Qty;
                    itemUpdate.Add(workItem);
                    itemDetailUpdate.Add(workDetailItem);
                    itemMesmorderList.Add(workOrderItem);
                    itemMesmorderEntryList.Add(workOrdEntryItem);

                    var planBOM = boms.Find(b => b.item_number == item.ItemNumber);
                    var pretreament = pretreatments.Where(c => c.sourceid == planBOM.mysql_id).ToList();
                    var returnlist = ObjectMapper.Map<List<b_bom_pretreatment>, List<BomChildExamineDto>>(pretreament);
                    returnlist = returnlist.OrderBy(s => s.num_order).ToList();
                    var level1Dto = returnlist[0];
                    level1Dto.qty = item.Qty;
                    CaclMaterialShortage(returnlist);
                    foreach (var child in returnlist)
                    {
                        var itemWorkOrdRoutingList = workOrdRoutingList.FindAll(w => w.WorkOrd == item.ProductionOrder);
                        if (itemWorkOrdRoutingList != null && itemWorkOrdRoutingList.Count > 0)
                        {
                            foreach (var r in itemWorkOrdRoutingList)
                            {
                                if (r.ItemNum == child.item_number)
                                {
                                    r.QtyOrded = child.needCount;
                                    itemRoutingUpdate.Add(r);
                                }
                            }
                        }
                    }
                }
                _workOrdMaster.Update(itemUpdate);
                _workOrdDetail.Update(itemDetailUpdate);
                _workOrdRouting.Update(itemRoutingUpdate);
                await _mysql_mes_morder.UpdateManyAsync(itemMesmorderList);
                await _mysql_mes_moentry.UpdateManyAsync(itemMesmorderEntryList);
            }

            //DOP运行资源检查每个原材料SKU的可用库存，当可用库存<=修正后ROP时，自动生成月度采购申请（Purchase request，PR46年月日4位流水号）=EOP；可用库存为没有被其他SO和PO占用的（合格原材料库存+在途库存）；
            var ropMaterialModelList = _replenishmentROPWeekPlan.GetListAsync(a => a.planmonth == $"{DateTime.Now.Year}-{DateTime.Now.Month.ToString("00")}" && a.erp_cls == 3 && a.distributionchannel == "瑞奇" && a.factory_id == input.factory_id && !a.IsDeleted).Result;
            
            List<srm_pr_main> prList = new List<srm_pr_main>();
            var numbers = ropMaterialModelList.Where(a => a.erp_cls == 3).Select(b => b.number).ToList();
            var icItemList = _mysql_ic_item.GetListAsync(c => numbers.Contains(c.number)).Result;
            var srm_pr_mains = _srm_pr_main.GetListAsync(x => icItemList.Select(p => p.Id).ToList().Contains(x.icitem_id.Value) && x.state != 0 && !x.IsDeleted && x.state != 4).Result;
            var quarter_srm_pr_mains = srm_pr_mains.Where(s => s.pr_psend_date >= _CalcBomViewAppService.quarter_starttime && s.pr_psend_date < _CalcBomViewAppService.quarter_endtime).ToList();
            var materialItemStock = _invMaster.Select(a => numbers.Contains(a.ItemNum) && a.Domain == input.factory_id.ToString());
            //更新未确认未合并的PR
            var prCanUpdateList = _mysql_srm_pr_main.GetListAsync(a => icItemList.Select(c => c.Id).ToList().Contains(a.icitem_id.GetValueOrDefault()) && a.pr_ssend_date >= DateTime.Now.Date.AddDays(1) && a.state==1).Result;
            List<srm_pr_main> prUpdateList = new List<srm_pr_main>();
            List<srm_pr_main> prDeleteList = new List<srm_pr_main>();
            ropMaterialModelList.ForEach(b =>
            {
                var materialQty=materialItemStock?.Where(c => c.ItemNum == b.number && c.Location.StartsWith('1'));
                decimal QtyStock = materialQty != null ? materialQty.Sum(c => c.AvailStatusQty.GetValueOrDefault() + c.Assay.GetValueOrDefault()) : 0;
                if (QtyStock < b.security_stock)
                {
                    mo_srm_purchase supplier = null;
                    var item = icItemList.Find(d => d.number == b.number);
                    var supplist = supplierList.Where(s => s.number == b.number).ToList();
                    decimal day = 0;
                    var plan_date = DateTime.Now.AddDays(1 + Convert.ToDouble(b.supply_leadtime));
                    //判断当前时间与交期还剩余多少天
                    var timesp = plan_date - DateTime.Now.Date;
                    //交期-生产时长-物料前处理周期
                    day = timesp.Days;
                    if (day > 0)
                    {
                        supplist = supplist.Where(s => s.lead_time.GetValueOrDefault() < day).ToList();
                        if (supplist.Any())
                        {
                            //TODO:走配额管理
                            List<mo_srm_pr_main> itemPrlist = quarter_srm_pr_mains.Where(s => s.icitem_id == item.Id).ToList();
                            if (itemPrlist.Any())
                            {
                                decimal qtyCount = itemPrlist.Sum(x => x.pr_aqty).GetValueOrDefault();
                                //按配额比例，计算使用哪个供应商。
                                List<PrPurchaseDto> PrPurchaseDtoList = new List<PrPurchaseDto>();
                                supplist.ForEach(s => {
                                    PrPurchaseDto purDto = new PrPurchaseDto();
                                    purDto.pr_purchaseid = s.supplier_id;
                                    purDto.num = itemPrlist.Where(x => x.pr_purchaseid == s.supplier_id).Sum(c => c.pr_aqty.GetValueOrDefault());
                                    purDto.ratio = Math.Round(purDto.num / qtyCount, 2, MidpointRounding.AwayFromZero);
                                    purDto.quota_priority = s.quota_priority;
                                    purDto.quota_rate = s.quota_rate.GetValueOrDefault();
                                    PrPurchaseDtoList.Add(purDto);
                                });

                                //首先取出占比还小于配额比的数据
                                var priorityPurlist = PrPurchaseDtoList.Where(s => s.quota_rate - s.ratio > 2).ToList();
                                if (!priorityPurlist.Any())
                                {
                                    //没有则取出当前集合中的供应商的数据，计算差额
                                    priorityPurlist = PrPurchaseDtoList;
                                }
                                //还没有达到配额比的供应商，优先分配
                                decimal difference = 0;
                                PrPurchaseDto dto1 = priorityPurlist[0];
                                priorityPurlist.ForEach(s => {
                                    decimal diff = s.quota_rate - s.ratio;
                                    if (diff > difference)
                                    {
                                        difference = diff;
                                        dto1 = s;
                                    }
                                });
                                supplier = supplist.Find(s => s.supplier_id == dto1.pr_purchaseid);
                            }
                            else
                            {
                                supplier = supplist.OrderBy(s => s.quota_priority).FirstOrDefault();//默认取配额优先级
                            }
                        }
                        else
                        {
                            supplier = supplist.OrderBy(s => s.quota_priority).FirstOrDefault();//默认取配额优先级
                        }
                    }
                    else
                    {
                        supplier = supplist.OrderBy(s => s.quota_priority).FirstOrDefault();//默认取配额优先级
                    }
                    srm_pr_main srm_Pr = new srm_pr_main();
                    srm_Pr.GenerateNewId(help.NextId());
                    srm_Pr.IsRequireGoods = supplier.IsRequireGoods;
                    srm_Pr.pr_purchaseid = supplier.supplier_id;//供应商id  
                    srm_Pr.pr_purchasenumber = supplier.supplier_number;//供应商编码
                    srm_Pr.pr_purchasename = supplier.supplier_name;//供应商名称
                    srm_Pr.pr_purchaser = supplier.order_rector_name;//采购员
                    srm_Pr.pr_purchaser_num = supplier.order_rector_num;//采购员工号（采购信息表）
                                                                        //数量圆整 按最小包装量向上圆整
                    decimal qty = Math.Max(b.eop.Value,b.security_stock.GetValueOrDefault()- QtyStock);
                    //判断最小起订量
                    qty = qty > supplier.qty_min ? qty : supplier.qty_min.GetValueOrDefault();
                    srm_Pr.pr_rqty = qty;//需求数量
                    srm_Pr.pr_aqty = qty;//申请数量
                    srm_Pr.pr_sqty = qty;//建议数量
                    srm_Pr.icitem_id = item.Id;//物料id
                    srm_Pr.icitem_name = b.name;//物料名称
                    srm_Pr.pr_order_type = "1";//单据类型
                    srm_Pr.pr_ssend_date = DateTime.Now.Date.AddDays(1);//系统建议下单日期
                    srm_Pr.pr_sarrive_date = DateTime.Now.AddDays((double)supplier.lead_time.GetValueOrDefault());//系统建议到达日期（建议到货日期）

                    srm_Pr.pr_sysprice = supplier.order_price;//系统价格（含税）
                    srm_Pr.pr_orderprice = qty * supplier.order_price;//订单价格（含税）
                    srm_Pr.pr_price = supplier.netpurchase_price;//采购净价（不含税）
                    srm_Pr.pr_rate = supplier.taxrate;//税率
                    srm_Pr.pr_unit = item.unit;//单位
                    srm_Pr.state = 1;//状态
                    srm_Pr.old_apply_aqty = 0;//已申请数量
                    srm_Pr.pr_type = b.erp_cls;//申请类型
                    srm_Pr.currencytype = supplier.currency_type == null ? 1 : supplier.currency_type.Value;//币种
                    srm_Pr.secInv_ratio = item.secinv_ratio;//安全库存触发采购比例
                    srm_Pr.tenant_id = input.tenant_id;
                    srm_Pr.company_id = input.company_id;
                    srm_Pr.factory_id = input.factory_id;
                    srm_Pr.create_time = DateTime.Now;
                    srm_Pr.create_by_name = "admin";
                    srm_Pr.update_time = DateTime.Now;
                    srm_Pr.update_by_name = "admin";
                    prList.Add(srm_Pr);
                }
                else if(QtyStock>b.max_stock_level)
                {
                    //扣减PR
                    var item = icItemList.Find(d => d.number == b.number);
                    var ItemPRList= prCanUpdateList.FindAll(a => a.icitem_id == item.Id);
                    if( ItemPRList.Any() )
                    {
                        ItemPRList=ItemPRList.OrderBy(a => a.pr_ssend_date).ToList();
                        var supplist = supplierList.Where(s => s.number == b.number).ToList();
                        
                        decimal? QtySub = b.max_stock_level - QtyStock;
                        for (int i=0;i<ItemPRList.Count;i++)
                        {
                            if(QtySub>0)
                            {
                                var supplier = supplist.Find(s => s.mysql_id == ItemPRList[i].pr_purchaseid);
                                //扣减的时候要不要考虑经济批量?
                                if (ItemPRList[i].pr_rqty < QtySub)
                                {
                                    prDeleteList.Add(ItemPRList[i]);
                                    QtySub = QtySub - ItemPRList[i].pr_rqty;
                                }
                                else
                                {
                                    if (ItemPRList[i].pr_rqty > supplier.qty_min)
                                    {
                                        if (ItemPRList[i].pr_rqty - supplier.qty_min > QtySub)
                                        {
                                            ItemPRList[i].pr_rqty = ItemPRList[i].pr_rqty - QtySub;
                                            prUpdateList.Add(ItemPRList[i]);
                                            break;
                                        }
                                        else
                                        {
                                            QtySub = QtySub - (ItemPRList[i].pr_rqty - supplier.qty_min);
                                            ItemPRList[i].pr_rqty = supplier.qty_min;
                                            prUpdateList.Add(ItemPRList[i]);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            });
            await _mysql_srm_pr_main.DeleteManyAsync(prDeleteList);
            await _mysql_srm_pr_main.UpdateManyAsync(prUpdateList);
            prList.ForEach(a =>
            {
                a.GenerateNewId(help.NextId());
            });
            await _mysql_srm_pr_main.InsertManyAsync(prList);
            return "OK";
        }

        /// <summary>
        /// 同步工单等相关数据
        /// </summary>
        /// <param name="morders"></param>
        /// <param name="allRoutings">工艺路线数据</param>
        public void CreateWorkOrdDates(List<mes_morder> morders, List<RoutingOpDetail> allRoutings, List<WorkOrdMaster> workOrds, List<WorkOrdRouting> workOrdRoutings, List<WorkOrdDetail> workOrdDetails, List<b_examine_result> exmResult, List<b_bom_child_examine> childExamineList)
        {
            //工单主表
            WorkOrdMaster workOrd;
            //工单工艺路线表
            WorkOrdRouting woRouting;
            //工单物料表
            var productStructureMs = _productStructureMaster.Select(x => morders.Select(c => c.morder_no).Contains(x.ParentItem) && x.Domain == param.factoryId.ToString());
            foreach (var item in morders)
            {
                var moItem = exmResult.Find(b => b.morder_no ==item.morder_no);
                //添加工单数据
                workOrd = new WorkOrdMaster();
                workOrd.Domain = item.factory_id.ToString();
                workOrd.OrdDate = item.moentry_sys_stime.GetValueOrDefault().Date;
                workOrd.ReleaseDate = Convert.ToDateTime(item.moentry_sys_stime.GetValueOrDefault().ToString("u"));
                workOrd.DueDate = item.moentry_sys_etime;
                workOrd.WorkOrd = item.morder_no;
                workOrd.ItemNum = item.product_code;//物料编码
                workOrd.QtyOrded = item.need_number.GetValueOrDefault();
                workOrd.Period = 1;
                workOrd.Priority = item.urgent;
                workOrd.Status = "";
                workOrd.IsActive = true;
                workOrd.IsConfirm = true;
                workOrd.CreateTime = DateTime.Now;
                workOrd.Typed = "";
                workOrd.SalesJob = item.morder_no;
                workOrds.Add(workOrd);

                //添加工单工艺路线数据
                var curRoutings = allRoutings.Where(p => p.RoutingCode == item.product_code).ToList();
                foreach (var dtl in curRoutings)
                {
                    woRouting = new WorkOrdRouting();
                    woRouting.Domain = item.factory_id.ToString();
                    woRouting.Descr = dtl.Descr;
                    woRouting.MilestoneOp = dtl.MilestoneOp;
                    woRouting.WorkOrd = item.morder_no;
                    woRouting.OP = dtl.Op;
                    woRouting.ParentOp = dtl.ParentOp;
                    woRouting.RunTime = dtl.RunTime;
                    woRouting.ItemNum = item.product_code;
                    woRouting.QtyOrded = item.need_number.GetValueOrDefault();
                    woRouting.OverlapUnits = dtl.OverlapUnits;
                    woRouting.Status = "";
                    woRouting.IsActive = true;
                    woRouting.CommentIndex = dtl.CommentIndex;
                    woRouting.CreateTime = DateTime.Now;
                    woRouting.PackingQty = dtl.PackingQty.GetValueOrDefault();
                    workOrdRoutings.Add(woRouting);
                }

                long fid = GetParentMo(morders, item);
                var exm = exmResult.Find(s => s.morder_id == fid);
                if (exm != null)
                {
                    var childs = childExamineList.Where(s => s.examine_id == exm.Id && s.is_use == true).ToList();

                    var child = childs.Find(s => s.item_number == item.product_code);
                    if (child == null)
                    {
                        continue;
                    }
                    List<b_bom_child_examine> returnList = new List<b_bom_child_examine>();
                    GetWorkDetalis(childs.Where(s => s.parent_id == child.fid).ToList(), returnList, childs);
                    if (returnList.Any())
                    {
                        WorkOrdDetail woDetail = null;
                        var calereturnList = returnList.Select(x => x.item_number).Distinct().ToList();
                        foreach (var caleNumber in calereturnList)
                        {
                            var caleList = returnList.Where(x => x.item_number == caleNumber).ToList();

                            //添加工单的物料信息
                            woDetail = new WorkOrdDetail();
                            woDetail.Domain = item.factory_id.ToString();
                            woDetail.WorkOrd = item.morder_no;
                            woDetail.Op = caleList.Max(f => f.Op);
                            woDetail.ItemNum = caleNumber;
                            woDetail.QtyPosted = 0m;
                            woDetail.QtyReturned = 0m;
                            woDetail.Status = "";
                            woDetail.IsActive = true;
                            woDetail.CreateTime = DateTime.Now;
                            woDetail.QtyRequired = caleList.Sum(c => c.needCount.GetValueOrDefault());
                            if (workOrd.QtyOrded != 0)
                            {
                                woDetail.FrozenBOMQty = Math.Round(woDetail.QtyRequired / workOrd.QtyOrded, 10);
                            }
                            workOrdDetails.Add(woDetail);
                        }
                    }
                }
            }
        }

        public long GetParentMo(List<mes_morder> morders, mes_morder item)
        {
            if (item.parent_id != null)
            {
                var parentMo = morders.Find(s => s.Id == item.parent_id);
                if (parentMo != null)
                {
                    return GetParentMo(morders, parentMo);
                }
                else
                {
                    return item.Id;
                }
            }
            else
            {
                return item.Id;
            }
        }

        /// <summary>
        /// 获取虚拟件明细
        /// </summary>
        /// <param name="dtl"></param>
        /// <param name="returnList"></param>
        /// <param name="childs"></param>
        public void GetWorkDetalis(List<b_bom_child_examine> dtl, List<b_bom_child_examine> returnList, List<b_bom_child_examine> childs)
        {
            returnList.AddRange(dtl);
            var rst = childs.Where(s => dtl.Where(x => x.erp_cls == 4).Select(c => c.fid).Contains(s.parent_id.GetValueOrDefault())).ToList();
            if (rst.Any())
            {
                GetWorkDetalis(rst, returnList, childs);
            }
            return;
        }


        /// <summary>
        /// 根据工单编号排优先级
        /// </summary>
        /// <param name="workOrdMasters">工单编号列表</param>
        /// <param name="domain">工厂编码</param>
        /// <returns></returns>
        //计算工单优先级
        public List<WorkOrdMaster> CalcPriority(List<string> workOrdMasters,string domain)
        {
            var works= _workOrdMaster.Select(a => workOrdMasters.Contains(a.WorkOrd) && a.Domain == domain && a.IsActive);
            var saleWordOrd = works.Where(a => !string.IsNullOrEmpty(a.SalesJob));
            Dictionary<string, int> dict = new Dictionary<string, int>();
            var soList=_mysql_crm_seorder.GetListAsync(a=> saleWordOrd.Select(b=>b.SalesJob).Contains(a.bill_no)).Result;
            
            var custList = _custMaster.Select(a => soList.Select(b => b.custom_no).Contains(a.Cust) && a.Domain == domain);
            //T1海外客户
            var T1CustList = custList.FindAll(a => a.Terms == "T1" || a.Terms == "海外").Select(a => a.Cust);
            //国科海王客户
            var T2CustList = custList.FindAll(a => a.Terms == "国科" || a.Terms == "海王").Select(a => a.Cust);
            //T1海外订单
            var T1SOList = soList.Where(a => T1CustList.Contains(a.custom_no)).Select(a => a.bill_no);
            //国科海王订单
            var T2SOList = soList.Where(a => T2CustList.Contains(a.custom_no)).Select(a => a.bill_no);
            //T1海外工单
            var T1WOList = saleWordOrd.Where(a => T1SOList.Contains(a.SalesJob)).ToList();
            //国科海王工单
            var T2WOList = saleWordOrd.Where(a => T2SOList.Contains(a.SalesJob)).ToList();
            //在制工单
            var inProductList = _mes_mooccupy.GetListAsync(a => works.Select(a => a.WorkOrd).Contains(a.moo_mo)).Result;

            //优先1：T1、海外销售订单新产生的生产指令；
            var T1WOListNew=T1WOList.Where(a=> !inProductList.Select(b=>b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a=>a.DueDate).ToList();
            //优先2：T1、海外销售订单关联的在制生产指令；
            var T1WOListInProduct = T1WOList.Where(a => inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先3：平台（国科、海王）销售订单新产生的生产指令；
            var T2WOListNew = T2WOList.Where(a => !inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先4：平台（国科、海王）销售订单关联的在制生产指令；
            var T2WOListInProduct = T2WOList.Where(a => !inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先5：除销售订单以外，计划补货订单关联的生产指令；
            var PlanWOList = works.Except(T1WOListNew).ToList();
            PlanWOList = works.Except(T1WOListInProduct).ToList();
            PlanWOList = works.Except(T2WOListNew).ToList();
            PlanWOList = works.Except(T2WOListInProduct).ToList();
            PlanWOList= PlanWOList.OrderBy(a => a.DueDate).ToList();
            //先按生产指令的类型，再按生产指令的完工日期顺序排产；
            List<WorkOrdMaster> orderedList = new List<WorkOrdMaster>();
            decimal Priority = 1.0m;
            for (int i=0;i< T1WOListNew.Count;i++)
            {
                T1WOListNew[i].Priority = Priority;
                orderedList.Add(T1WOListNew[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < T1WOListInProduct.Count; i++)
            {
                T1WOListInProduct[i].Priority = Priority;
                orderedList.Add(T1WOListInProduct[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < T2WOListNew.Count; i++)
            {
                T2WOListNew[i].Priority = Priority;
                orderedList.Add(T2WOListNew[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < T2WOListInProduct.Count; i++)
            {
                T2WOListInProduct[i].Priority = Priority;
                orderedList.Add(T2WOListInProduct[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < PlanWOList.Count; i++)
            {
                PlanWOList[i].Priority = Priority;
                orderedList.Add(PlanWOList[i]);
                Priority = Priority + 1.0m;
            }
            return orderedList;
        }

        /// <summary>
        /// 根据工单排优先级(用于先排优先级再写入的场景)
        /// </summary>
        /// <param name="workOrdMasters">工单编号列表</param>
        /// <param name="domain">工厂编码</param>
        /// <returns></returns>
        //计算工单优先级
        public List<WorkOrdMaster> CalcPriority(List<WorkOrdMaster> works, string domain)
        {
            var saleWordOrd = works.Where(a => !string.IsNullOrEmpty(a.SalesJob));
            var soList = _mysql_crm_seorder.GetListAsync(a => saleWordOrd.Select(b => b.SalesJob).Contains(a.bill_no)).Result;

            var custList = _custMaster.Select(a => soList.Select(b => b.custom_no).Contains(a.Cust) && a.Domain == domain);
            //T1海外客户
            var T1CustList = custList.FindAll(a => a.Terms == "T1" || a.Terms == "海外").Select(a => a.Cust);
            //国科海王客户
            var T2CustList = custList.FindAll(a => a.Terms == "国科" || a.Terms == "海王").Select(a => a.Cust);
            //T1海外订单
            var T1SOList = soList.Where(a => T1CustList.Contains(a.custom_no)).Select(a => a.bill_no);
            //国科海王订单
            var T2SOList = soList.Where(a => T2CustList.Contains(a.custom_no)).Select(a => a.bill_no);
            //T1海外工单
            var T1WOList = saleWordOrd.Where(a => T1SOList.Contains(a.SalesJob)).ToList();
            //国科海王工单
            var T2WOList = saleWordOrd.Where(a => T2SOList.Contains(a.SalesJob)).ToList();
            //在制工单
            var inProductList = _mes_mooccupy.GetListAsync(a => works.Select(a => a.WorkOrd).Contains(a.moo_mo)).Result;

            //优先1：T1、海外销售订单新产生的生产指令；
            var T1WOListNew = T1WOList.Where(a => !inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先2：T1、海外销售订单关联的在制生产指令；
            var T1WOListInProduct = T1WOList.Where(a => inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先3：平台（国科、海王）销售订单新产生的生产指令；
            var T2WOListNew = T2WOList.Where(a => !inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先4：平台（国科、海王）销售订单关联的在制生产指令；
            var T2WOListInProduct = T2WOList.Where(a => !inProductList.Select(b => b.moo_mo).Contains(a.WorkOrd))?.OrderBy(a => a.DueDate).ToList();
            //优先5：除销售订单以外，计划补货订单关联的生产指令；
            var PlanWOList = works.Except(T1WOListNew).ToList();
            PlanWOList = works.Except(T1WOListInProduct).ToList();
            PlanWOList = works.Except(T2WOListNew).ToList();
            PlanWOList = works.Except(T2WOListInProduct).ToList();
            PlanWOList = PlanWOList.OrderBy(a => a.DueDate).ToList();
            //先按生产指令的类型，再按生产指令的完工日期顺序排产；
            List<WorkOrdMaster> orderedList = new List<WorkOrdMaster>();
            decimal Priority = 1.0m;
            for (int i = 0; i < T1WOListNew.Count; i++)
            {
                T1WOListNew[i].Priority = Priority;
                orderedList.Add(T1WOListNew[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < T1WOListInProduct.Count; i++)
            {
                T1WOListInProduct[i].Priority = Priority;
                orderedList.Add(T1WOListInProduct[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < T2WOListNew.Count; i++)
            {
                T2WOListNew[i].Priority = Priority;
                orderedList.Add(T2WOListNew[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < T2WOListInProduct.Count; i++)
            {
                T2WOListInProduct[i].Priority = Priority;
                orderedList.Add(T2WOListInProduct[i]);
                Priority = Priority + 1.0m;
            }

            for (int i = 0; i < PlanWOList.Count; i++)
            {
                PlanWOList[i].Priority = Priority;
                orderedList.Add(PlanWOList[i]);
                Priority = Priority + 1.0m;
            }
            return orderedList;
        }

        /// <summary>
        /// 手动调整优先级
        /// </summary>
        /// <param name="workOrdMasters">工单编号列表</param>
        /// <param name="domain">工厂编码</param>
        /// <returns></returns>
        //计算工单优先级
        public async Task<string> ChangePriority(string weekplanid, string tenant_id, string factory_id, string company_id, string itemNumber, string qty, string instockdate, string priority)
        {
            try
            {
                if (string.IsNullOrEmpty(qty))
                    return "数量不正确，请检查";
                if (string.IsNullOrEmpty(instockdate))
                    return "成品入库日期不正确，请检查";
                if (string.IsNullOrEmpty(priority))
                    return "优先级不正确，请检查";
                decimal newpriority=Convert.ToDecimal(priority);
                DateTime newinstockdate=Convert.ToDateTime(instockdate);
                decimal newqty=Convert.ToDecimal(qty);
                long id= Convert.ToInt64(weekplanid);
                long tenantid=Convert.ToInt64(tenant_id);
                long factoryid=Convert.ToInt64(factory_id);
                long companyid=Convert.ToInt64(company_id);
                var weekPlan=_replenishmentWeekPlan.FindAsync(a => a.Id == id && a.tenant_id == tenantid && a.factory_id == factoryid && a.company_id == companyid).Result;
                var isExistSamePriority= _replenishmentWeekPlan.FindAsync(a => a.Id != id && a.Week == weekPlan.Week && a.Priority == newpriority).Result;
                if(isExistSamePriority!=null)
                    return "优先级重复，请重新调整。";
                weekPlan.Priority= newpriority;
                weekPlan.Qty= newqty;
                weekPlan.InStockDate= newinstockdate;
                await _replenishmentWeekPlan.UpdateAsync(weekPlan);
            }
            catch(Exception e)
            {
                return "调整失败，请联系管理员。";
            }
            return "ok";
        }

        /// <summary>
        /// 根据物料编码获取可用库存
        /// 成品半成品可用库存为没有被其他SO和PO占用的（合格成品或半成品库存+WIP)
        /// 原材料可用库存为没有被其他SO和PO占用的（合格原材料库存+在途库存）；
        /// </summary>
        /// <param name="itemNumbers">物料编码列表</param>
        /// <returns></returns>
        public List<EOPDto> CalcStock(List<string> itemNumbers,InputDto input)
        {
            List<EOPDto> itemQty = new List<EOPDto>();
            var itemList=_mysql_ic_item.GetListAsync(a => itemNumbers.Contains(a.number) && a.factory_id == input.factory_id  && !a.IsDeleted).Result;
            var itemStockList=_mysql_ic_item_stock.GetListAsync(a => itemNumbers.Contains(a.icitem_number) && a.factory_id == input.factory_id  && !a.IsDeleted).Result;
            var pooccupylist=_mysql_srm_po_occupy.GetListAsync(a => a.state == 1 && !a.IsDeleted && a.factory_id == input.factory_id ).Result;
            var poList = _mysql_srm_po_list.GetListAsync(a=> pooccupylist.Select(p=>p.polist_id).ToList().Contains(a.Id) && pooccupylist.Select(p => p.polist_row).ToList().Contains(a.polist_row) && a.factory_id == input.factory_id  && !a.IsDeleted).Result;
            var molist=_mysql_mes_morder.GetListAsync(a => itemNumbers.Contains(a.product_code) && a.factory_id == input.factory_id  && !a.IsDeleted).Result;
            var proccupylist=_mysql_srm_pr_main_occupy.GetListAsync(a=> molist.Select(p=>p.morder_no).ToList().Contains(a.morder_mo) && a.factory_id == input.factory_id  && !a.IsDeleted).Result;

            //TODO:完善占用逻辑
            //srm_pr_main pr = new srm_pr_main();
            //pr.state = 1;
            //srm_po_main po = new srm_po_main();
            ////po.state.GetValueOrDefault() != 3;
            //srm_po_occupy srm_Po_Occupy = new srm_po_occupy();
            ////srm_Po_Occupy.polist_id = pr.Id;po.id;

            itemNumbers.ForEach(a =>
            {
                EOPDto eOPDto=new EOPDto();
                eOPDto.ItemNumber = a;
                decimal stockqty = 0;
                if(itemStockList.Find(s => s.icitem_number == a)!=null)
                {
                    stockqty = itemStockList.Find(s => s.icitem_number == a).sqty.Value;
                }
                decimal poOccupyQty = 0;
                for(int i=0;i<pooccupylist.Count;i++)
                {
                    for(int j=0;j<poList.Count;j++)
                    {
                        if (pooccupylist[i].polist_id== poList[j].Id && pooccupylist[i].polist_row == poList[j].polist_row && poList[j].ItemNum==a)
                        {
                            poOccupyQty += pooccupylist[i].qty.Value;
                        }
                    }
                }

                decimal prOccupyQty = 0;
                for (int i = 0; i < proccupylist.Count; i++)
                {
                    for (int j = 0; j < molist.Count; j++)
                    {
                        if (proccupylist[i].morder_mo == molist[j].morder_no  && molist[j].product_code == a)
                        {
                            prOccupyQty += proccupylist[i].qty.Value;
                        }
                    }
                }
                eOPDto.Qty = stockqty - poOccupyQty - prOccupyQty;
                itemQty.Add(eOPDto);
            });
            return itemQty;
        }

        /// <summary>
        /// 计划工单齐套检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> PlanOrderResourceCheck(List<mes_morder> Mes_Morders, List<mes_moentry> moentryList,long bangid, InputDto input)
        {
            if (Mes_Morders.Any())
            {
                //Mes_Morders.ForEach(s => { s.moentry_sys_stime = DateTime.Now.Date.AddDays((double)lookDay + 1); });
                List<string> monolist = Mes_Morders.Select(c => c.morder_no).ToList();
                //清理PR的占用。
                //如果PR没有转PO，则PR没有合并，就删除，有合并，就减少合并后的PR的数量。
                //var prlist = _mysql_srm_pr_main.GetListAsync(s => monolist.Contains(s.pr_mono)).Result;
                //List<srm_pr_main> alllist = new List<srm_pr_main>();
                //List<srm_pr_main> updatelist = new List<srm_pr_main>();
                //List<srm_pr_main> dellist = new List<srm_pr_main>();
                //RecursionGetDbPr2(prlist, alllist);
                //foreach (var pr in prlist)
                //{
                //    //找到没有关闭的PR，如果关联上的PR都是已关闭，则说明已经转了PO。
                //    //TODO:解决Database operation expected to affect 1 row(s) but actually affected 0 row(s). 如果业务逻辑有问题自行修改
                //    var getPr = RerunPr(pr, alllist);
                //    if (getPr != null)
                //    {
                //        if (getPr.pr_aqty - pr.pr_aqty <= 0)
                //        {
                //            //删除这个pr，没有小于0则是更新
                //            dellist.Add(getPr);
                //        }
                //        else
                //        {
                //            getPr.pr_aqty = getPr.pr_aqty - pr.pr_aqty;
                //            updatelist.Add(getPr);
                //        }
                //    }
                //}
                List<srm_po_occupy> occupy = await _mysql_srm_po_occupy.GetListAsync(s => monolist.Contains(s.morder_mo));
                _businessDbContext.BulkDelete(occupy);
                //if (updatelist.Any())
                //{
                //    _businessDbContext.BulkUpdate(updatelist);
                //}
                //if (dellist.Any())
                //{
                //    _businessDbContext.BulkDelete(dellist);
                //}
                //清理掉库存占用
                var itemstockoccupy = _mysql_ic_item_stockoccupy.GetListAsync(s => monolist.Contains(s.morder_mo)).Result;
                if (itemstockoccupy.Any())
                {
                    _businessDbContext.BulkDelete(itemstockoccupy);
                }
                //清理锁定期外的排程数据.
                //var periodList = _periodSequenceDet.Select(s => monolist.Contains(s.WorkOrds));
                //if (periodList.Any())
                //{
                //    _periodSequenceDet.Delete(s => monolist.Contains(s.WorkOrds));
                //}
                //var schedulList = _scheduleResultOpMaster.Select(s => monolist.Contains(s.WorkOrd));
                //if (schedulList.Any())
                //{
                //    _scheduleResultOpMaster.Delete(s => monolist.Contains(s.WorkOrd));
                //}
                //只走计划工单
                var rtn = await OrderKittingCheck(Mes_Morders, moentryList, bangid, true);
            }
            else
            {
                return "未查找到对应的计划工单，请联系管理员。";
            }
            return "ok";
        }

        //找到没有关闭的PR，做数量的减少
        public srm_pr_main RerunPr(srm_pr_main pr, List<srm_pr_main> referlist)
        {
            //如果当前PR已经关闭，则检查合并数据
            if (pr.state == 0)
            {
                //已关闭，并且没有关联数据，则代表转PO了。
                var refPr = referlist.Find(s => s.pr_billno == pr.refer_pr_billno);
                //如果有关联，继续往下查
                if (refPr != null)
                {
                    return RerunPr(refPr, referlist);
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return pr;
            }
        }

        /// <summary>
        /// 递归寻找PR,找到合并后的PR
        /// </summary>
        public void RecursionGetDbPr2(List<srm_pr_main> list, List<srm_pr_main> referlist)
        {
            List<srm_pr_main> prlist = _mysql_srm_pr_main.GetListAsync(s => list.Select(c => c.refer_pr_billno).Contains(s.pr_billno)).Result;
            if (prlist.Any())
            {
                referlist.AddRange(prlist);
                RecursionGetDbPr2(prlist, referlist);
            }
        }

        /// <summary>
        /// 工单检查物料齐套
        /// </summary>
        /// <param name="input"></param>
        public async Task<PschedDto> OrderKittingCheck(List<mes_morder> mo_Mes_Morders, List<mes_moentry> moentryList,long bangid, bool planCheck = false)
        {
            //资源检查结果
            PschedDto rtn = new PschedDto();
            //资源检查明细list
            List<ExamineResult> examines = new List<ExamineResult>();
            OrderCheckDto input = new OrderCheckDto();
            if (mo_Mes_Morders.Any())
            {
                input.company_id = mo_Mes_Morders[0].company_id;
                input.factoryId = mo_Mes_Morders[0].factory_id.GetValueOrDefault();
            }
            //资源检查入参全局变量赋值
            param.company_id = input.company_id;
            param.factoryId = input.factoryId;
            param.checkflag = false;
            param.checkPlan = planCheck;

            /*List<mo_mes_morder> mo_Mes_Morders = _mes_morder.GetManyByCondition(x => x.start_time > DateTime
            .Now.Date.AddDays(1) && x.start_time < DateTime
            .Now.Date.AddDays(input.Day) && x.morder_state == MorderEnum.Initial_state && !x.IsDeleted && x.tenant_id == param.tenantId && x.bang_id == bangid).Result;

            List<mo_mes_moentry> mo_Mes_Moentries = _mes_moentry.GetManyByCondition(x=> mo_Mes_Morders.Select(s => s.id).Contains(x.moentry_moid.Value)).Result;*/

            var morderIdList = mo_Mes_Morders.Select(s => s.Id).ToList();

            //List<mes_moentry> mo_Mes_Moentries = _mysql_mes_moentry.GetListAsync(x => morderIdList.Contains(x.moentry_moid.Value)).Result;
            List<mes_moentry> mo_Mes_Moentries = moentryList;
            //获取订单行数据
            List<crm_seorderentry> sentrys = _mysql_crm_seorderentry.GetListAsync(p => p.factory_id == input.factoryId && !p.IsDeleted && mo_Mes_Moentries.Select(x => x.soentry_id).Contains(p.Id)).Result;

            //删除同步Mysql后旧数据
            await DeleteMySqlOldData(sentrys);

            List<mo_ic_bom> boms = _ic_bom.GetListAsync(p => mo_Mes_Morders.Select(m => m.bom_number).Contains(p.bom_number) && p.factory_id == input.factoryId && !p.IsDeleted).Result.ToList();

            //物料bom
            List<mo_ic_bom> bomlist = new List<mo_ic_bom>();
            //物料bom明细
            List<mo_ic_bom_child> bomchildlist = new List<mo_ic_bom_child>();
            //物料信息
            List<mo_ic_item> icitemlist = new List<mo_ic_item>();
            //替代关系
            List<mo_ic_substitute> sublist = new List<mo_ic_substitute>();
            List<mo_ic_substitute_group> suballlist = new List<mo_ic_substitute_group>();
            List<mo_ic_substitute_group_detail> subdtllist = new List<mo_ic_substitute_group_detail>();
            //物料库存表
            List<mo_ic_item_stock> stocklist = new List<mo_ic_item_stock>();
            //物料占用记录
            List<mo_ic_item_stockoccupy> sklist = new List<mo_ic_item_stockoccupy>();

            //sorder=null  是因为齐套检查不需要生成工单、采购、委外等信息，所以不需要关联的工单信息传递进去。
            var pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            List<mo_ic_bom> autoCreates = new List<mo_ic_bom>();
            boms.ForEach(p =>
            {
                if (!pretreatments.Where(s => s.sourceid == p.mysql_id).Any())
                {
                    autoCreates.Add(p);
                }
            });
            if (autoCreates.Any())
            {
                AutoCreateBomBill(param.company_id.ToString(), autoCreates);
                pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            }
            AsyncItemStockFromWMS(pretreatments);

            //数据库快照-同步mysql库数据到mongoDB中
            await DbSnapShot(input.company_id, input.factoryId, bangid, pretreatments);
            
            DataInitialization(boms, bangid, icitemlist, stocklist, pretreatments, sklist);
            _CalcBomViewAppService.param = param;
            foreach (var item in mo_Mes_Morders)
            {
                var moentry = mo_Mes_Moentries.Find(s => s.moentry_moid == item.Id);
                if (moentry == null)
                {
                    continue;
                }
                var sentry = sentrys.Find(s => s.Id == moentry.soentry_id);

                //工单资源检查信息
                ExamineResult dtl = new ExamineResult();
                dtl.morder_id = item.Id;
                dtl.morder_no = item.morder_no;
                dtl.bangid = bangid;
                dtl.order_statr_time = item.start_time;
                dtl.bom_number = item.bom_number;
                dtl.need_qty = item.need_number.GetValueOrDefault();

                //获取当前物料bom数据
                var childBom = boms.Where(p => p.bom_number == item.bom_number).FirstOrDefault();

                var itemPrelist = pretreatments.Where(s => s.sourceid == childBom.mysql_id).ToList();
                if (!itemPrelist.Any())
                {
                    continue;
                }

                var getBomList = ObjectMapper.Map<List<b_bom_pretreatment>, List<BomChildExamineDto>>(itemPrelist);

                if (sentry != null)
                {
                    dtl.sentry_id = sentry.Id;
                    getBomList.ForEach(s => s.sentry_id = item.Id);
                }
                _CalcBomViewAppService.newStockOccList = new List<mo_ic_item_stockoccupy>();
                _CalcBomViewAppService.mes_morder = item;
                _CalcBomViewAppService.morder_type = item.morder_type;
                //库存初始化
                _CalcBomViewAppService.BomStock(getBomList, stocklist, bangid);

                //计算
                _CalcBomViewAppService.CalcView(getBomList, bangid, item.need_number.GetValueOrDefault(), item.moentry_sys_stime, sklist, sentry, icitemlist);

                //TODO:最晚开始时间
                var curFacDtl = leadTimeList.FirstOrDefault(p => p.item_id == childBom.icitem_id);
                //物料齐套时间
                dtl.kitting_times = getBomList.Where(p => p.is_use && p.kitting_time != null).OrderByDescending(m => m.kitting_time).First().kitting_time.GetValueOrDefault();
                //替代关系展开list
                dtl.BomChildExamineList = getBomList;
                //添加订单行开工信息
                examines.Add(dtl);
            }
            rtn.examines = examines;
            if (planCheck)
            {
                //如果有计划工单，则需要生成pr po oo
                List<mo_srm_pr_main> prmainlist = new List<mo_srm_pr_main>();
                if (_CalcBomViewAppService.SRMPRDtoList.Any())
                {
                    List<List<mo_srm_pr_main>> prlist = _CalcBomViewAppService.SRMPRDtoList.Where(f => f.srm_Pr_Main != null).Select(s => s.srm_Pr_Main).ToList();
                    List<mo_srm_pr_main> list = new List<mo_srm_pr_main>();

                    foreach (var pr in prlist)
                    {
                        foreach (var item in pr)
                        {
                            list.Add(item);
                            prmainlist.Add(item);
                        }
                    }
                    if (list.Any())
                        rtn.srm_pr_list = _CalcBomViewAppService.SRMPRDtoList;
                }
                string seqSql = "";
                if (prmainlist.Any())
                {
                    var nbrlistDto = _serialNumberAppService.GetBillNo(prmainlist[0].factory_id.ToString(), "PR", prmainlist.Count, "admin", 1);
                    int index = 0;
                    foreach (var p in prmainlist)
                    {
                        if (nbrlistDto[index] != null)
                        {
                            p.pr_billno = nbrlistDto[index].NbrResult.ToString();
                        }
                        index++;
                        if (p.pr_purchaseid.GetValueOrDefault() == 0)
                        {
                            //数据丢失
                            var list = _mysql_srm_purchase.GetListAsync(s => s.icitem_id == p.icitem_id).Result;
                            if (list.Any())
                            {
                                var purchase = list.OrderBy(s => s.quota_priority).FirstOrDefault();
                                p.pr_purchaseid = purchase.supplier_id;
                                p.pr_purchasename = purchase.supplier_name;
                                p.pr_purchasenumber = purchase.supplier_number;
                            }
                        }
                    }
                    var prapplyList = prmainlist.Where(s => s.IsRequireGoods != 1).ToList();
                    if (prapplyList.Any())
                    {
                        //请购单插入事务
                        var rstSeqId = _serialNumberAppService.GetSeqIdList(prapplyList[0].factory_id.ToString(), 1, 1);
                        long seqId = 0;
                        if (long.TryParse(rstSeqId, out seqId))
                        {
                            prapplyList.ForEach(p =>
                            {
                                seqSql += "insert QadTracking(Ufld1,Domain,SeqID,TransType,Subject,[Order],Int1,CreateTime,CreateUser,UpdateTime,UpdateUser) values('C','" + p.factory_id.ToString() +
                                    "'," + seqId.ToString() + ",'nbr-pr-mes','请购单','" + p.pr_billno + "'," + p.mysql_id.ToString() + ",getdate(),'',getdate(),'');";
                                seqId++;
                            });
                        }
                    }
                }

                //获取工单数据
                var workOrdMasters = _workOrdMaster.Select(p => mo_Mes_Morders.Select(c => c.morder_no).Contains(p.WorkOrd));
                workOrdMasters.ForEach(s => {
                    var mo = mo_Mes_Morders.Find(m => m.morder_no == s.WorkOrd);
                    if (mo != null)
                    {
                        //锁定期
                        s.OrdDate = mo.moentry_sys_stime;
                        s.DueDate = mo.moentry_sys_stime;
                    }

                });
                using (var unitOfWork = _unitOfWorkManager.Begin(false, true))
                {
                    try
                    {
                        _businessDbContext.BulkUpdate(mo_Mes_Morders);
                        if (prmainlist.Any())
                        {
                            var pr_mainlist = ObjectMapper.Map<List<mo_srm_pr_main>, List<srm_pr_main>>(prmainlist);
                            _businessDbContext.BulkInsert(pr_mainlist);
                            if (!string.IsNullOrEmpty(seqSql))
                            {
                                _businessBangDbContext.Database.ExecuteSqlRaw(seqSql);
                            }
                        }
                        if (_CalcBomViewAppService.newStockOccList.Any())
                        {
                            var stockoccupylist = ObjectMapper.Map<List<mo_ic_item_stockoccupy>, List<ic_item_stockoccupy>>(_CalcBomViewAppService.newStockOccList);
                            stockoccupylist.ForEach(s => { s.GenerateNewId(help.NextId()); s.create_time = DateTime.Now; s.tenant_id = param.company_id.GetValueOrDefault(); s.company_id = param.company_id; s.factory_id = param.factoryId; });
                            _businessDbContext.BulkInsert(stockoccupylist);
                        }
                        if (_CalcBomViewAppService.srm_Po_OccupiesInsert.Any())
                        {
                            _CalcBomViewAppService.srm_Po_OccupiesInsert.ForEach(s => { s.company_id = param.company_id; s.factory_id = param.factoryId; });
                            var srmpooccupyInsert = ObjectMapper.Map<List<mo_srm_po_occupy>, List<srm_po_occupy>>(_CalcBomViewAppService.srm_Po_OccupiesInsert);
                            _businessDbContext.BulkInsert(srmpooccupyInsert);
                        }
                        await unitOfWork.CompleteAsync();
                    }
                    catch (Exception e)
                    {
                        unitOfWork.Dispose();
                        new NLogHelper("ResourceExamineAppService").WriteLog("OrderKittingCheck", "工单检查数据更新失败：" + e.Message, _currentTenant.Id.ToString());
                    }
                }

            }
            //检查结果写入数据库
            await ExamineResultInsertDBAsync(examines);
            //清空快照数据
            await ClearSnapShot(bangid);
            return rtn;
        }

        public async Task ExamineResultInsertDBAsync(List<ExamineResult> examines)
        {
            //检查结果写入数据库
            List<b_examine_result> examineList = new List<b_examine_result>();
            List<b_bom_child_examine> bomExamineList = new List<b_bom_child_examine>();
            List<b_mo_occupy> mooccupyList = new List<b_mo_occupy>();
            List<b_mo_order> moorderList = new List<b_mo_order>();
            List<b_ooder> ooderList = new List<b_ooder>();
            List<b_purchase> purchaseList = new List<b_purchase>();
            List<b_purchase_occupy> purchaseoccupyList = new List<b_purchase_occupy>();

            foreach (var ex in examines)
            {
                var b_ex = ObjectMapper.Map<ExamineResult, b_examine_result>(ex);
                b_ex.GenerateNewId(help.NextId());// = help.NextId();
                if (_CalcBomViewAppService.mordersInsertList.Any())
                {
                    var sentryMo = _CalcBomViewAppService.mordersInsertList.Where(s => s.mysql_id == b_ex.morder_id).FirstOrDefault();
                    if (sentryMo != null)
                    {
                        b_ex.morder_id = sentryMo.mysql_id;
                        b_ex.morder_no = sentryMo.morder_no;
                    }
                }
                b_ex.create_time = DateTime.Now;
                b_ex.company_id = param.company_id;
                b_ex.tenant_id = param.company_id;
                b_ex.factory_id = param.factoryId;
                examineList.Add(b_ex);
                ex.BomChildExamineList.ForEach(s =>
                {
                    var bc_ex = ObjectMapper.Map<BomChildExamineDto, b_bom_child_examine>(s);
                    bc_ex.GenerateNewId(help.NextId());
                    bc_ex.examine_id = b_ex.Id;
                    bc_ex.company_id = param.company_id;
                    bc_ex.tenant_id = param.company_id;
                    bc_ex.factory_id = param.factoryId;
                    bc_ex.create_time = DateTime.Now;
                    bomExamineList.Add(bc_ex);

                    if (s.mo_occupy_list != null)
                    {
                        var olist = ObjectMapper.Map<List<mo_occupy>, List<b_mo_occupy>>(s.mo_occupy_list);
                        olist.ForEach(o =>
                        {
                            o.bom_child_examine_id = bc_ex.Id; o.company_id = param.company_id; o.tenant_id = param.company_id;
                            o.factory_id = param.factoryId;
                        });
                        mooccupyList.AddRange(olist);
                    }
                    if (s.make_list != null)
                    {
                        var mlist = ObjectMapper.Map<List<moorder>, List<b_mo_order>>(s.make_list);
                        mlist.ForEach(o =>
                        {
                            o.bom_child_examine_id = bc_ex.Id; o.company_id = param.company_id; o.tenant_id = param.company_id;
                            o.factory_id = param.factoryId;
                        });
                        moorderList.AddRange(mlist);
                    }
                    if (s.subcontracting_list != null)
                    {
                        var slist = ObjectMapper.Map<List<ooder>, List<b_ooder>>(s.subcontracting_list);
                        slist.ForEach(o =>
                        {
                            o.bom_child_examine_id = bc_ex.Id; o.company_id = param.company_id; o.tenant_id = param.company_id;
                            o.factory_id = param.factoryId;
                        });
                        ooderList.AddRange(slist);
                    }
                    if (s.purchase_list != null)
                    {
                        var plist = ObjectMapper.Map<List<purchase>, List<b_purchase>>(s.purchase_list);
                        plist.ForEach(o =>
                        {
                            o.bom_child_examine_id = bc_ex.Id; o.company_id = param.company_id; o.tenant_id = param.company_id;
                            o.factory_id = param.factoryId;
                        });
                        purchaseList.AddRange(plist);
                    }
                    if (s.purchase_occupy_list != null)
                    {
                        var purlist = ObjectMapper.Map<List<purchase_occupy>, List<b_purchase_occupy>>(s.purchase_occupy_list);
                        purlist.ForEach(o =>
                        {
                            o.bom_child_examine_id = bc_ex.Id; o.company_id = param.company_id; o.tenant_id = param.company_id;
                            o.factory_id = param.factoryId;
                        });
                        purchaseoccupyList.AddRange(purlist);
                    }
                });
            }
            using (var unitOfWork = _unitOfWorkManager.Begin(false, true))
            {
                try
                {
                    if (examineList.Any())
                    {
                        _businessBangDbContext.BulkInsert(examineList);
                    }
                    if (bomExamineList.Any())
                    {
                        _businessBangDbContext.BulkInsert(bomExamineList.OrderBy(s => s.num_order).ToList());
                    }
                    if (mooccupyList.Any())
                    {
                        _businessBangDbContext.BulkInsert(mooccupyList);
                    }
                    if (moorderList.Any())
                    {
                        _businessBangDbContext.BulkInsert(moorderList);
                    }
                    if (ooderList.Any())
                    {
                        _businessBangDbContext.BulkInsert(ooderList);
                    }
                    if (purchaseList.Any())
                    {
                        _businessBangDbContext.BulkInsert(purchaseList);
                    }
                    if (purchaseoccupyList.Any())
                    {
                        _businessBangDbContext.BulkInsert(purchaseoccupyList);
                    }
                    await unitOfWork.CompleteAsync();
                }
                catch (Exception e)
                {
                    new NLogHelper("ResourceExamineAppService").WriteLog("ReceiveResult", "资源检查计算结果相关数据更新失败：" + e.Message, _currentTenant.Id.ToString());
                    unitOfWork.Dispose();
                }
            }
        }

        /// <summary>
        /// 删除旧订单行数据
        /// </summary>
        /// <param name="tenantId"></param>
        /// <param name="factoryId"></param>
        /// <param name="soentry_id"></param>
        /// <returns></returns>
        public async Task DeleteMySqlOldData(List<crm_seorderentry> soentry_id)
        {
            List<long> sentryids = soentry_id.Select(p => p.Id).ToList();
            //删除工单相关表数据
            /*var mes_moentry = _mysql_mes_moentry.GetListAsync(x => sentryids.Contains(x.soentry_id.Value)).Result;

            var mes_morder = _mysql_mes_morder.GetListAsync(x => mes_moentry.Select(p => p.moentry_moid).ToList().Contains(x.Id)).Result;
            if (mes_moentry.Count > 0)
            {
                await _mysql_mes_moentry.DeleteManyAsync(mes_moentry);
            }
            if (mes_morder.Count > 0)
            {
                await _mysql_mes_morder.DeleteManyAsync(mes_morder);
            }*/
            var mysql_mes_mooccupy = _mysql_mes_mooccupy.GetListAsync(x => soentry_id.Select(p => p.Id).Contains(x.moo_id_billid.Value)).Result;
            if (mysql_mes_mooccupy.Count > 0)
            {
                await _mysql_mes_mooccupy.DeleteManyAsync(mysql_mes_mooccupy);
            }
            /*var srm_pr_main = _mysql_srm_pr_main.GetListAsync(x => soentry_id.Select(p => p.Id).Contains(x.sentry_id.GetValueOrDefault())).Result;
            if (srm_pr_main.Count > 0)
            {
                await _mysql_srm_pr_main.DeleteManyAsync(srm_pr_main);
            }*/
            /*var mes_oorders = _mysql_mes_oorder.GetListAsync(x => soentry_id.Select(p => p.Id).Contains(x.sentry_id.GetValueOrDefault())).Result;
            if (mes_oorders.Count > 0)
            {
                await _mysql_mes_oorder.DeleteManyAsync(mes_oorders);
            }*/
        }

        /// <summary>
        /// 数据库快照
        /// </summary>
        /// <returns></returns>
        public async Task DbSnapShot(long? companyId, long factoryId, long bangid, List<b_bom_pretreatment> pretreatments)
        {
            //TODO:申老师明确后续需要调整 根据需要使用的字段，来同步表数据。

            //同步物料库存数据  根据预处理，来只找出部分数据同步。
            List<long> itemIds = pretreatments.Select(s => s.item_id.GetValueOrDefault()).ToList();
            //var icitemStokc = _mysql_ic_item_stock.GetListAsync(p => p.tenant_id == tenantId && p.factory_id == factoryId).Result;
            var icitemStokc = _mysql_ic_item_stock.GetListAsync(p => p.company_id == companyId && itemIds.Contains(p.icitem_id)).Result;
            if (icitemStokc.Count > 0)
            {
                List<string> numbers = pretreatments.Select(s => s.item_number).ToList();
                List<string> locationList = new List<string> { "1000", "1001", "5008", "8000", "8001" };
                var locStock = _invMaster.Select(a => numbers.Contains(a.ItemNum) && a.IsActive && a.Domain == factoryId.ToString() && locationList.Contains(a.Location));
                //设置当前计算bangid
                icitemStokc.ForEach(item => {
                    item.bang_id = bangid;
                    var pret = pretreatments.Find(s => s.item_id == item.icitem_id);
                    if (pret != null)
                    {
                        item.sqty = locStock.Where(s => s.ItemNum == pret.item_number).Sum(p => p.AvailStatusQty.GetValueOrDefault() + p.Assay.GetValueOrDefault());
                    }
                });
                var moIcitemStokc = ObjectMapper.Map<List<ic_item_stock>, List<mo_ic_item_stock>>(icitemStokc);
                moIcitemStokc.ForEach(item => { item.GenerateNewId(help.NextId()); });
                //插入数据
                await _ic_item_stock.InsertManyAsync(moIcitemStokc);
            }

            var workordmsters = _workOrdMaster.Select(s => s.Domain == factoryId.ToString() && string.IsNullOrEmpty(s.Status) != true && s.Status.ToLower() != "c");
            if (workordmsters.Any())
            {
                //根据工单表找到工单明细，然后根据DOP工单占用记录，对比工单明细发货数量，来做冲销。
                var workdetails = _workOrdDetail.Select(s => workordmsters.Select(c => c.WorkOrd).Contains(s.WorkOrd));

                //物料库存占用记录表
                var item_occupy = _mysql_ic_item_stockoccupy.GetListAsync(p => p.company_id == companyId && itemIds.Contains(p.icitem_id) && workordmsters.Select(c => c.WorkOrd).Contains(p.morder_mo)).Result;
                if (item_occupy.Any())
                {
                    item_occupy.ForEach(s =>
                    {
                        //TODO：对发布数量和占用数量进行对冲，因为目前没有处理不同层级下使用相同物料的占用的问题。dop占用有项次号，而wms的发布数量明细没有项次号
                        var wdtl = workdetails.Where(x => x.WorkOrd == s.morder_mo && x.ItemNum == s.icitem_number).ToList();
                        if (wdtl.Any())
                        {
                            foreach (var dtl in wdtl)
                            {
                                if (s.quantity - dtl.QtyPosted > 0)
                                {
                                    s.quantity -= dtl.QtyPosted;
                                    dtl.QtyPosted = 0;
                                }
                                else
                                {
                                    dtl.QtyPosted -= s.quantity;
                                    s.quantity = 0;
                                }
                            }
                        }
                    });
                    item_occupy = item_occupy.Where(s => s.quantity > 0).ToList();
                    if (item_occupy.Count > 0)
                    {
                        var mo_item_occupy = ObjectMapper.Map<List<ic_item_stockoccupy>, List<mo_ic_item_stockoccupy>>(item_occupy);
                        mo_item_occupy.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                        await _ic_item_stockoccupy.InsertManyAsync(mo_item_occupy);
                    }
                }

                //工单主表
                var mes_morder = _mysql_mes_morder.GetListAsync(x => string.IsNullOrEmpty(x.morder_state) == false && x.morder_state != "完成" && x.company_id == companyId && x.factory_id == factoryId && workordmsters.Select(c => c.WorkOrd).Contains(x.morder_no)).Result;
                if (mes_morder.Count > 0)
                {
                    mes_morder.ForEach(item => { item.bang_id = bangid; });
                    var moMes_morder = ObjectMapper.Map<List<mes_morder>, List<mo_mes_morder>>(mes_morder);
                    moMes_morder.ForEach(item => { item.GenerateNewId(help.NextId()); });
                    await _mes_morder.InsertManyAsync(moMes_morder);
                }
                //工单子表
                var mes_moentry = _mysql_mes_moentry.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId).Result;
                if (mes_moentry.Count > 0)
                {
                    mes_moentry.ForEach(item => { item.bang_id = bangid; });
                    var moMes_moentry = ObjectMapper.Map<List<mes_moentry>, List<mo_mes_moentry>>(mes_moentry);
                    moMes_moentry.ForEach(item => { item.GenerateNewId(help.NextId()); });
                    await _mes_moentry.InsertManyAsync(moMes_moentry);
                }

                //在制工单占用记录表
                var mes_mooccupy = _mysql_mes_mooccupy.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId && mes_morder.Select(c => c.morder_no).Contains(x.moo_mo)).Result;
                if (mes_mooccupy.Count > 0)
                {
                    var moMes_mooccupy = ObjectMapper.Map<List<mes_mooccupy>, List<mo_mes_mooccupy>>(mes_mooccupy);
                    moMes_mooccupy.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                    await _mes_mooccupy.InsertManyAsync(moMes_mooccupy);
                }
            }
            //根据物料信息，只同步在途未关闭的采购订单和采购申请

            //采购订单明细
            var srm_po_list = _mysql_srm_po_list.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId && itemIds.Contains(x.icitem_id.GetValueOrDefault())).Result;
            if (srm_po_list.Count > 0)
            {
                //采购订单--取出状态为在途的PO
                var srm_po_main = _mysql_srm_po_main.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId && srm_po_list.Select(c => c.po_id).Contains(x.Id) && x.state != 3).Result;
                if (srm_po_main.Count > 0)
                {
                    var moSrm_po_main = ObjectMapper.Map<List<srm_po_main>, List<mo_srm_po_main>>(srm_po_main);
                    moSrm_po_main.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                    await _srm_po_main.InsertManyAsync(moSrm_po_main);

                    //订单明细--根据在途PO过滤出有效的Po_list
                    srm_po_list = srm_po_list.Where(s => srm_po_main.Select(x => x.Id).Contains(s.po_id.GetValueOrDefault())).ToList();
                    var moSrm_po_list = ObjectMapper.Map<List<srm_po_list>, List<mo_srm_po_list>>(srm_po_list);
                    moSrm_po_list.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                    await _srm_po_list.InsertManyAsync(moSrm_po_list);
                }
                //采购订单明细占用详情
                var srm_po_occupy = _mysql_srm_po_occupy.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId && srm_po_list.Select(c => c.Id).Contains(x.polist_id.GetValueOrDefault())).Result;
                if (srm_po_occupy.Count > 0)
                {
                    var moSrm_po_occupy = ObjectMapper.Map<List<srm_po_occupy>, List<mo_srm_po_occupy>>(srm_po_occupy);
                    moSrm_po_occupy.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                    await _srm_po_occupy.InsertManyAsync(moSrm_po_occupy);
                }
            }

            //pr
            var srm_pr_main = _mysql_srm_pr_main.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId && x.state != 0 && itemIds.Contains(x.icitem_id.GetValueOrDefault())).Result;
            if (srm_pr_main.Count > 0)
            {
                var moSrm_pr_main = ObjectMapper.Map<List<srm_pr_main>, List<mo_srm_pr_main>>(srm_pr_main);
                moSrm_pr_main.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                await _srm_pr_main.InsertManyAsync(moSrm_pr_main);

                //采购申请占用详情
                var srm_pr_occupy = _mysql_srm_po_occupy.GetListAsync(x => x.company_id == companyId && x.factory_id == factoryId && srm_pr_main.Select(c => c.Id).Contains(x.polist_id.GetValueOrDefault())).Result;
                if (srm_pr_occupy.Count > 0)
                {
                    var moSrm_pr_occupy = ObjectMapper.Map<List<srm_po_occupy>, List<mo_srm_po_occupy>>(srm_pr_occupy);
                    moSrm_pr_occupy.ForEach(item => { item.GenerateNewId(help.NextId()); item.bang_id = bangid; });
                    await _srm_po_occupy.InsertManyAsync(moSrm_pr_occupy);
                }
            }
        }

        /// <summary>
        /// 清处数据库快照
        /// </summary>
        /// <returns></returns>
        public async Task ClearSnapShot(long bangid)
        {
            //清除物料库存数据
            await _ic_item_stock.DeleteAsync(p => p.bang_id == bangid);

            //清除工单占用记录表
            //await _mes_mooccupy.DeleteAsync(p => p.bang_id == bangid);

            //清除工单主表
            //await _mes_morder.Delete(p => p.bang_id == bangid);

            //清除工单子表
            //await _mes_moentry.Delete(p => p.bang_id == bangid);

            //清除采购订单
            await _srm_po_main.DeleteAsync(p => p.bang_id == bangid);

            //清除采购订单明细
            await _srm_po_list.DeleteAsync(p => p.bang_id == bangid);

            //清除采购订单占用详情
            //await _srm_po_occupy.DeleteAsync(p => p.bang_id == bangid);

            //清除PR
            await _srm_pr_main.DeleteAsync(p => p.bang_id == bangid);
        }


        /// <summary>
        /// 物料数据计算前准备
        /// </summary>
        /// <param name="boms"></param>
        /// <param name="bangid"></param>
        /// <param name="sorder"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        /// <param name="icitemlist"></param>
        /// <param name="sublist"></param>
        /// <param name="suballlist"></param>
        /// <param name="subdtllist"></param>
        /// <param name="stocklist"></param>
        /// <param name="sklist"></param>
        /// <exception cref="NotImplementedException"></exception>
        public void DataInitialization(List<mo_ic_bom> boms, long bangid, List<mo_ic_item> icitemlist, List<mo_ic_item_stock> stocklist, List<b_bom_pretreatment> pretreatments, List<mo_ic_item_stockoccupy> sklist)
        {
            List<long> itemIds = pretreatments.Select(p => p.item_id.GetValueOrDefault()).ToList();
            icitemlist.AddRange(_ic_item.GetListAsync(p => itemIds.Contains(p.mysql_id) && !p.IsDeleted).Result);
            #region 1、数据准备
            //1.1、获取产能检查相关数据
            //产品物料编码
            List<string> itemnums = pretreatments.Where(p => p.level == 1).Select(p => p.item_number).Distinct().ToList();
            //产线明细
            prodLines = _prodLineDetail.Select(p => itemnums.Contains(p.Part)).ToList();
            //标准工序
            routingOps = _routingOpDetail.Select(p => itemnums.Contains(p.RoutingCode)).ToList();
            List<string> lines = prodLines.Select(p => p.Line).Distinct().ToList();
            //工作日历
            calendarWorks = _shopCalendarWorkCtr.Select(p => lines.Contains(p.ProdLine)).ToList();
            //休息日
            qualityLineWorks = _qualityLineWorkDetail.Select(p => lines.Contains(p.ProdLine)).ToList();
            //节假日
            holidays = _holidayMaster.Select(p => p.Dated >= DateTime.Now.Date);

            //主工单
            var ordlist = _workOrdMaster.Select(x => x.Domain == param.factoryId.ToString() && string.IsNullOrEmpty(x.Typed) == true && (x.Status.ToLower() == "p" || x.Status.ToLower() == "r")).ToList();
            List<mo_mes_morder> mo_Mes_Morders = _mes_morder.GetListAsync(x => boms.Select(p => p.item_number).Contains(x.product_code) && ordlist.Select(c => c.WorkOrd).Contains(x.morder_no) && x.company_id == param.company_id && x.factory_id == param.factoryId && x.bang_id == bangid).Result;
            List<long> moids = mo_Mes_Morders.Select(p => p.mysql_id).ToList();
            List<mo_mes_moentry> mo_Mes_Moentry = _mes_moentry.GetListAsync(x => moids.Contains(x.moentry_moid)).Result;
            //工单占用表
            List<mo_mes_mooccupy> mes_mooccupyList = _mes_mooccupy.GetListAsync(x => x.moo_state == 1 && !x.IsDeleted && x.company_id == param.company_id
          && boms.Select(p => p.item_number).Contains(x.fitem_number) && x.bang_id == bangid).Result;

            List<long> occoupyRefId = new List<long>();
            //物料采购订单明细
            var poDetailList = _srm_po_list.GetListAsync(x => icitemlist.Select(p => p.mysql_id).ToList().Contains(x.icitem_id.Value) && x.bang_id == bangid && x.state == 1 && !x.IsDeleted).Result;
            occoupyRefId.AddRange(poDetailList.Select(p => p.Id).ToList());
            var srm_pr_mains = _srm_pr_main.GetListAsync(x => icitemlist.Select(p => p.mysql_id).ToList().Contains(x.icitem_id.Value) && x.bang_id == bangid && x.state != 0 && x.state != 4 && !x.IsDeleted).Result;
            occoupyRefId.AddRange(srm_pr_mains.Select(p => p.Id).ToList());
            //采购订单或采购申请占用数据
            var poOccupys = _srm_po_occupy.GetListAsync(x => occoupyRefId.Contains(x.polist_id) && x.bang_id == bangid && !x.IsDeleted).Result;
            #endregion

            //物料库存
            stocklist.AddRange(_ic_item_stock.GetListAsync(p => p.factory_id == param.factoryId && p.bang_id == bangid && itemIds.Contains(p.icitem_id)).Result);
            //物料库存占用表
            sklist.AddRange(_ic_item_stockoccupy.GetListAsync(x => x.bang_id == bangid && !x.IsDeleted).Result);

            //物料提前期
            leadTimeList = GetLeadTime(icitemlist, param.company_id, param.factoryId);//提前期列表
            supplierList = GetSupplier(itemIds, param.company_id, param.factoryId);//供应商列表

            _CalcBomViewAppService.leadTimeList = leadTimeList;
            _CalcBomViewAppService.supplierList = supplierList;

            //资源检查添加产线工序等数据
            _CalcBomViewAppService.prodLines = prodLines;
            _CalcBomViewAppService.routingOps = routingOps;
            _CalcBomViewAppService.calendarWorks = calendarWorks;
            _CalcBomViewAppService.qualityLineWorks = qualityLineWorks;
            _CalcBomViewAppService.holidays = holidays;

            _CalcBomViewAppService.mordersList = mo_Mes_Morders;//工单
            _CalcBomViewAppService.moentriesList = mo_Mes_Moentry;//工单子表
            _CalcBomViewAppService.mooccupyAllList = mes_mooccupyList;//工单占用表

            _CalcBomViewAppService.srm_Po_Lists = poDetailList; //采购明细
            _CalcBomViewAppService.srm_Po_Occupies = poOccupys; //采购占用表
            _CalcBomViewAppService.ic_item_List = icitemlist; //物料表
            _CalcBomViewAppService.srm_Pr_Mains = srm_pr_mains;//PR
        }


        public void GenerateSort(List<BomChildExamineDto> returnlist)
        {
            int level = returnlist.Max(s => s.level);
            returnlist.ForEach(s =>
            {
                int num = level - s.level;
                if (num > 0)
                {
                    s.num_order = long.Parse((s.num_order * Math.Pow(1000, num)).ToString());
                }
            });
        }

        /// <summary>
        /// 根据物料id获取物料4个提前期
        /// </summary>
        /// <param name="icItemIds">物料id</param>
        /// <param name="tenantId">企业id</param>
        /// <param name="factoryid">工厂id</param>
        /// <returns></returns>
        private List<ICItemLeadTimeDto> GetLeadTime(List<mo_ic_item> icItemIds, long? companyId, long factoryid)
        {
            return icItemIds.Where(p => p.factory_id == factoryid && p.company_id == companyId && !p.IsDeleted).
                Select(x => new ICItemLeadTimeDto
                {
                    item_id = x.mysql_id,
                    transportation_leadtime = x.transportation_leadtime,
                    stock_leadtime = x.stock_leadtime,
                    production_leadtime = x.production_leadtime,
                    order_leadtime = x.order_leadtime,
                    minorderqty = x.minorderqty,
                    put_integer = x.put_integer,
                    minpackqty = x.minpackqty,
                    ordissu_days = x.ordissu_days
                }).AsQueryable<ICItemLeadTimeDto>().ToList();
        }

        //根据物料id获取物料供应商
        private List<mo_srm_purchase> GetSupplier(List<long> icItemIds, long? companyId, long factoryid)
        {
            return _srm_purchase.GetListAsync(p => icItemIds.Contains(p.icitem_id) && p.company_id == companyId && p.factory_id == factoryid && !p.IsDeleted).Result;
        }


        /// <summary>
        /// 物料和BOM前置数据准备
        /// </summary>
        /// <param name="boms"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        /// <param name="icitemlist"></param>
        /// <param name="sublist"></param>
        /// <param name="suballlist"></param>
        /// <param name="subdtllist"></param>
        public void IcItemPretreatment(bool flag, List<mo_ic_bom> boms, List<mo_ic_bom> bomlist, List<mo_ic_bom_child> bomchildlist, List<mo_ic_item> icitemlist, List<mo_ic_substitute> sublist, List<mo_ic_substitute_group> suballlist, List<mo_ic_substitute_group_detail> subdtllist)
        {
            //获取物料bom，物料bom明细
            GetIcBomData(boms, bomlist, bomchildlist, flag);

            //根据明细集合查出所有得替代关系表数据集合
            List<string> codeList = bomchildlist.Select(c => c.substitute_code).Distinct().ToList();
            sublist.AddRange(_ic_substitute.GetListAsync(p => codeList.Contains(p.substitute_code) && !p.IsDeleted).Result);

            List<long> subidlist = sublist.Select(c => c.mysql_id).Distinct().ToList();
            suballlist.AddRange(_ic_substitute_group.GetListAsync(p => subidlist.Contains(p.substitute_group_id) && !p.IsDeleted).Result);

            List<long> suballidlist = suballlist.Select(c => c.mysql_id).Distinct().ToList();
            subdtllist.AddRange(_ic_substitute_group_detail.GetListAsync(p => suballidlist.Contains(p.substitute_group_id) && !p.IsDeleted).Result);

            //获取物料数据
            List<long> itemIds = bomlist.Select(p => p.icitem_id).ToList();
            itemIds.AddRange(bomchildlist.Select(p => p.icitem_id).ToList());
            itemIds.AddRange(subdtllist.Select(p => p.icitem_id).ToList());
            icitemlist.AddRange(_ic_item.GetListAsync(p => itemIds.Contains(p.mysql_id) && !p.IsDeleted).Result);
        }

        /// <summary>
        /// 递归:获取icbom,icbomchild数据
        /// </summary>
        /// <param name="icBoms"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        public void GetIcBomData(List<mo_ic_bom> icBoms, List<mo_ic_bom> bomlist, List<mo_ic_bom_child> bomchildlist, bool flag)
        {
            if (icBoms.Count == 0)
            {
                return;
            }
            //添加物料bom数据
            foreach (var ib in icBoms)
            {
                if (!bomlist.Exists(s => s.mysql_id == ib.mysql_id))
                {
                    bomlist.Add(ib);
                }
            }
            List<long> icBomIds = icBoms.Select(m => m.mysql_id).ToList();
            int page = 1;
            page = (int)Math.Ceiling(icBomIds.Count() / (decimal)1500);
            List<mo_ic_bom_child> childList = new List<mo_ic_bom_child>();
            for (int i = 0; i < page; i++)
            {
                var pageBomsIds = icBomIds.Skip(i * 1500).Take(1500).ToList();
                childList.AddRange(_ic_bom_child.GetListAsync(p => pageBomsIds.Contains(p.bom_id) && p.company_id == param.company_id && !p.IsDeleted).Result);
            }
            //没有明细数据,终止
            if (childList.Count == 0)
            {
                return;
            }
            foreach (var bchild in childList)
            {
                if (!bomchildlist.Exists(s => s.mysql_id == bchild.mysql_id))
                {
                    bomchildlist.Add(bchild);
                }
            }
            if (flag)
            { return; }
            //通过物料bom明细数据反查物料bom数据
            var boms = _ic_bom.GetListAsync(p => childList.Select(m => m.icitem_id).ToList().Contains(p.icitem_id) && p.use_status == 1 && p.company_id == param.company_id && !p.IsDeleted).Result.ToList();
            foreach (var chd in childList)
            {
                var curBoms = boms.Where(p => p.icitem_id == chd.icitem_id).ToList();
                GetIcBomData(curBoms, bomlist, bomchildlist, flag);
            }
        }


        /// <summary>
        /// 自动生成BOM预处理清单
        /// </summary>
        public void AutoCreateBomBill(string companyid, List<mo_ic_bom> ic_Boms = null)
        {
            bool flag = false;
            if (ic_Boms == null)
            {
                flag = true;
                ic_Boms = _ic_bom.GetListAsync(p => p.company_id.ToString() == companyid && !p.IsDeleted).Result.ToList();
            }
            var pretreatment = _mysql_b_bom_pretreatment.GetListAsync(s => ic_Boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;

            param.company_id = long.Parse(companyid);

            //物料bom
            List<mo_ic_bom> bomlist = new List<mo_ic_bom>();
            List<mo_ic_bom_child> bomchildlist = new List<mo_ic_bom_child>();
            //物料信息
            List<mo_ic_item> icitemlist = new List<mo_ic_item>();
            //替代关系
            List<mo_ic_substitute> sublist = new List<mo_ic_substitute>();
            List<mo_ic_substitute_group> suballlist = new List<mo_ic_substitute_group>();
            List<mo_ic_substitute_group_detail> subdtllist = new List<mo_ic_substitute_group_detail>();
            IcItemPretreatment(flag, ic_Boms, bomlist, bomchildlist, icitemlist, sublist, suballlist, subdtllist);

            List<b_bom_pretreatment> deleteList = new List<b_bom_pretreatment>();
            List<b_bom_pretreatment> addList = new List<b_bom_pretreatment>();
            foreach (var bom in ic_Boms)
            {
                var pret = pretreatment.Find(s => s.sourceid == bom.mysql_id && s.bom_id == bom.mysql_id);
                if (pret != null)
                {
                    if (pret.version == bom.version)
                    {
                        //如果存在，且版本相同，则不需要处理
                        continue;
                    }
                    //版本不同则重新生成
                    deleteList.Add(pret);
                }
                //bom层级组装
                var getBomList = _pretreatmentAppService.BomPretreatment(bom.mysql_id, bomlist, bomchildlist, icitemlist);
                //bom替代关系组装
                _pretreatmentAppService.BomSubstitute(getBomList, bomlist, bomchildlist, icitemlist, sublist, suballlist, subdtllist);

                //GenerateSort(getBomList);
                var list = ObjectMapper.Map<List<BomChildExamineDto>, List<b_bom_pretreatment>>(getBomList);
                list.ForEach(s =>
                {
                    s.sourceid = bom.mysql_id;
                    s.company_id = bom.company_id;
                    s.tenant_id = bom.tenant_id;
                    s.factory_id = bom.factory_id;
                });
                addList.AddRange(list);
            }
            if (deleteList.Any())
            {
                _businessDbContext.BulkDelete(deleteList);
            }
            if (addList.Any())
            {
                _businessDbContext.BulkInsert(addList);

                //await _mysql_b_bom_pretreatment.InsertManyAsync(addList);
            }
        }

        /// <summary>
        /// 生产长周期物料PR
        /// </summary>
        /// <param name="input">需要传入工厂编码</param>
        /// <returns></returns>
        public async Task<string> CalcLongPeriodItemPR(InputDto input)
        {
            input.year = DateTime.Now.Year;
            input.month = DateTime.Now.Month;
            var ropParam = GetROPParam(input.factory_id.ToString());
            //获取滚动未来六个月数据
            var monthlist = GetPlanMonth(6);
            var productList = _replenishmentAnnualProduction.GetListAsync(a => monthlist.Contains(a.PlanMonth) && !a.IsDeleted && a.factory_id == input.factory_id).Result.OrderBy(s=>s.OrderNum).ToList();
            var itemList= productList.Select(a=>a.SAPItemNumber).ToList();
            var planList=_mysql_ic_item.GetListAsync(a=>itemList.Contains(a.number) && a.factory_id==input.factory_id && !a.IsDeleted).Result.ToList();
            var mesItem=_itemMaster.Select(a => itemList.Contains(a.ItemNum) &&a.IsActive && a.Domain==input.factory_id.ToString());
            var bomList = _mysql_ic_bom.GetListAsync(a => itemList.Contains(a.item_number) && !a.IsDeleted && a.factory_id == input.factory_id).Result;
            List<mes_morder> moList=new List<mes_morder>();
            List<mes_moentry> moentryList = new List<mes_moentry>();
            var list = _serialNumberAppService.GetBillNo(input.factory_id.ToString(), "M5", productList.Count(), "", 1);
            long bangid = help.NextId();
            for (int i = 0;i< productList.Count();i++)
            {
                var ic_item = planList.Find(x => x.number == productList[i].SAPItemNumber);
                var bom = bomList.Find(a => a.item_number == productList[i].SAPItemNumber);
                if (ic_item.PurLT < ropParam.LongPeriodDay)
                    continue;
                mes_morder mes_Morder = new mes_morder();
                mes_Morder.GenerateNewId(help.NextId());
                mes_Morder.morder_type = MorderEnum.JhMorder;
                //mes_Morder.morder_icitem_type
                mes_Morder.work_order_type = MorderEnum.CgMorder;
                mes_Morder.morder_state ="";
                mes_Morder.morder_no = list[i].NbrResult.ToString();
                mes_Morder.fms_number = ic_item.fms_number;
                mes_Morder.bom_number = bom.bom_number;
                mes_Morder.fmodel = ic_item.model;
                mes_Morder.urgent = 1;
                mes_Morder.moentry_startup_status = 0;
                mes_Morder.tenant_id = input.tenant_id;
                mes_Morder.factory_id = input.factory_id;
                mes_Morder.company_id = input.company_id;
                mes_Morder.org_id = input.org_id;
                mes_Morder.product_code = ic_item.number;
                mes_Morder.product_name = ic_item.name;
                mes_Morder.morder_date = DateTime.Now.Date.AddDays(1);
                mes_Morder.moentry_sys_stime= Convert.ToDateTime(productList[i].PlanMonth + "-01");
                //mes_Morder.morder_fstate = "计划";
                //TODO:目前没有取值位置
                mes_Morder.moentry_prd = null;
                mes_Morder.moentry_prdname = null;
                mes_Morder.moentry_wrkc = null;
                mes_Morder.moentry_wrkcname = null;
                mes_Morder.picking_qty = 0;
                //TODO:可删除主表字段
                mes_Morder.unit = ic_item.unit;
                mes_Morder.morder_production_number = productList[i].Qty;
                mes_Morder.need_number = productList[i].Qty;
                mes_Morder.remaining_number = 0;
                mes_Morder.create_time = DateTime.Now;
                //生成工单子表数据
                mes_moentry mes_Moentry = new mes_moentry();
                mes_Moentry.GenerateNewId(help.NextId());
                mes_Moentry.moentry_moid = mes_Morder.Id;
                mes_Moentry.moentry_mono = mes_Morder.morder_no;
                mes_Moentry.unit = ic_item.unit;
                mes_Moentry.morder_production_number = productList[i].Qty;
                mes_Moentry.need_number = productList[i].Qty;
                mes_Moentry.remaining_number = 0;
                mes_Moentry.tenant_id = input.tenant_id;
                mes_Moentry.factory_id = input.factory_id;
                mes_Moentry.company_id = input.company_id;
                mes_Moentry.org_id = input.org_id;
                mes_Moentry.create_time = DateTime.Now;

                moList.Add(mes_Morder);
                moentryList.Add(mes_Moentry);
            }
            //长周期物料只产生PR不生成实际工单
            //await _mysql_mes_morder.InsertManyAsync(moList);
            //await _mysql_mes_moentry.InsertManyAsync(moentryList);
            await PlanOrderResourceCheck(moList,moentryList, bangid,input);
            return "OK";
        }

        public ReplenishmentDto GetROPParam(string domain)
        {
            //select [Domain],Val,Ufld1,UDeci1 from GeneralizedCodeMaster where [Domain] = '1001' AND FldName ='SystemConfig' 
            //  AND Val IN('ReplenishmentCalcPeriod', 'HistoryOutStockMonth', 'SaleFcstMonth', 'SaleFcstEntryDate', 'UpdateWeeks', 'WeekPlanUpdateDay', 'LongPeriodDay')
            List<string> list = new List<string>();
            list.Add("ReplenishmentCalcPeriod");
            list.Add("HistoryOutStockMonth");
            list.Add("SaleFcstMonth");
            list.Add("SaleFcstEntryDate");
            list.Add("UpdateWeeks");
            list.Add("WeekPlanUpdateDay");
            list.Add("LongPeriodDay");
            var configList = _generalizedCodeMaster.Select(a => a.Domain == domain && a.FldName == "SystemConfig" && list.Contains(a.Val));

            ReplenishmentDto replenishmentDto = new ReplenishmentDto();
            replenishmentDto.HistoryOutStockMonth = 3;
            replenishmentDto.ReplenishmentCalcPeriod = "W";
            replenishmentDto.HistoryOutStockMonth = 2;
            replenishmentDto.SaleFcstMonth = 2;
            replenishmentDto.SaleFcstEntryDate = 27;
            replenishmentDto.UpdateWeeks = 12;
            replenishmentDto.WeekPlanUpdateDay = 7;//每周日更新
            replenishmentDto.LongPeriodDay = 60;
            if (configList?.Find(a => a.Val == "HistoryOutStockMonth") != null)
            {
                replenishmentDto.HistoryOutStockMonth = (int)configList?.Find(a => a.Val == "HistoryOutStockMonth").UDeci1;
            }
            if (configList?.Find(a => a.Val == "ReplenishmentCalcPeriod") != null)
            {
                switch (configList?.Find(a => a.Val == "ReplenishmentCalcPeriod").Ufld1)
                {
                    case "月":
                        replenishmentDto.ReplenishmentCalcPeriod = "M";
                        break;
                    case "周":
                        replenishmentDto.ReplenishmentCalcPeriod = "W";
                        break;
                    case "":
                        replenishmentDto.ReplenishmentCalcPeriod = "D";
                        break;
                    default:
                        replenishmentDto.ReplenishmentCalcPeriod = "W";
                        break;
                }
            }
            if (configList?.Find(a => a.Val == "SaleFcstMonth") != null)
            {
                replenishmentDto.SaleFcstMonth = (int)configList?.Find(a => a.Val == "SaleFcstMonth").UDeci1;
            }

            if (configList?.Find(a => a.Val == "SaleFcstEntryDate") != null)
            {
                replenishmentDto.SaleFcstEntryDate = (int)configList?.Find(a => a.Val == "SaleFcstEntryDate").UDeci1;
            }

            if (configList?.Find(a => a.Val == "UpdateWeeks") != null)
            {
                replenishmentDto.UpdateWeeks = (int)configList?.Find(a => a.Val == "UpdateWeeks").UDeci1;
            }

            if (configList?.Find(a => a.Val == "WeekPlanUpdateDay") != null)
            {
                switch (configList?.Find(a => a.Val == "WeekPlanUpdateDay").Ufld1)
                {
                    case "周一":
                        replenishmentDto.WeekPlanUpdateDay = 1;
                        break;
                    case "周二":
                        replenishmentDto.WeekPlanUpdateDay = 2;
                        break;
                    case "周三":
                        replenishmentDto.WeekPlanUpdateDay = 3;
                        break;
                    case "周四":
                        replenishmentDto.WeekPlanUpdateDay = 4;
                        break;
                    case "周五":
                        replenishmentDto.WeekPlanUpdateDay = 5;
                        break;
                    case "周六":
                        replenishmentDto.WeekPlanUpdateDay = 6;
                        break;
                    case "周日":
                        replenishmentDto.WeekPlanUpdateDay = 7;
                        break;
                    default:
                        replenishmentDto.WeekPlanUpdateDay = 7;
                        break;
                }
            }

            if (configList?.Find(a => a.Val == "LongPeriodDay") != null)
            {
                replenishmentDto.LongPeriodDay = (int)configList?.Find(a => a.Val == "LongPeriodDay").UDeci1;
            }
            return replenishmentDto;
        }

        /// <summary>
        /// 计算ABC分类和FMR分类
        /// </summary>
        /// <param name="replenishmentModels"></param>
        public void CalcFMRAndABC(ReplenishmentROPWeekPlan replenishmentModel, ReplenishmentDto replenishmentDto, List<ASNBOLShipperDetail> shipList, List<InvTransHist> pickbilllist, InputDto input)
        {
            //总的移库次数
            int totalCount = shipList.Count() + pickbilllist.Count();
            //平均出库次数
            decimal avgOutStock = totalCount / replenishmentDto.HistoryOutStockMonth;
            //瑞奇不提供价格敏感信息，ABC类都默认为B，全部当做无出库金额的物料
            //无出库金额的物料 FMR分类  F   96 % M   90 % R   80 %
            //有出库金额的物料 ABC/ FMR分类   AF  96 % AM  90 % AR  80 % BF  96 % BM  90 % BR  80 % CF  96 % CM  90 % CR  80 % 
            replenishmentModel.abc = "B";//原材料默认为B

            int itemMoveCount = shipList.Count(a => a.ContainerItem == replenishmentModel.number) + pickbilllist.Count(a => a.ItemNum == replenishmentModel.number);
            if (itemMoveCount >= avgOutStock)
            {
                replenishmentModel.fmr = "F";
            }
            else if (itemMoveCount >= avgOutStock / 2 && itemMoveCount < avgOutStock || itemMoveCount == 0)
            {
                replenishmentModel.fmr = "M";//没有出库移库记录的默认为M
            }
            else if (itemMoveCount < avgOutStock / 2)
            {
                replenishmentModel.fmr = "R";
            }

            if (replenishmentModel.fmr == "F")
            {
                replenishmentModel.service_level_pct = (decimal?)0.96;
            }
            if (replenishmentModel.fmr == "M")
            {
                replenishmentModel.service_level_pct = (decimal?)0.9;
            }
            if (replenishmentModel.fmr == "R")
            {
                replenishmentModel.service_level_pct = (decimal?)0.8;
            }
        }

        /// <summary>
        /// 算平均月需求数量
        /// </summary>
        /// <param name="planList">发货计划</param>
        /// <param name="itemGroup"></param>
        /// <param name="itemNum"></param>
        /// <param name="month"></param>
        /// <returns></returns>
        public decimal CalcAvgDemand(List<MonthlyShipmentPlan> list, string itemNum,int? erp_cls, List<InvTransHist> pickbilllist=null)
        {
            if(erp_cls!=3)
            {
                if(list.Where(i => i.SAPItemNumber == itemNum && i.DistributionChannel=="瑞奇").Count()>0)
                {
                    return list.Where(i => i.SAPItemNumber == itemNum && i.DistributionChannel == "瑞奇").Average(a => a.Qty);
                }
                return 0;
            }else
            {
                var pickItemList = pickbilllist.Select(a => a.ItemNum).Distinct();
                var sumQty = pickbilllist.Where(a => a.ItemNum == itemNum)?.Sum(a => a.QtyChange);
                var month = pickbilllist.Where(a => a.ItemNum == itemNum)?.Select(a => a.CreateTime.Value.Month).Distinct().Count();
                if (month == 0)
                    return sumQty.Value;
                else
                    return sumQty.GetValueOrDefault()/month.Value;
            } 
        }

        public double CalcVariance(List<MonthlyShipmentPlan> list, string itemNum, int? erp_cls,decimal? monthl_avg_demand, List<InvTransHist> pickbilllist = null)
        {
            if (erp_cls != 3)
            {
                var nums = list.Where(i => i.SAPItemNumber == itemNum).Select(a => a.Qty);
                if (nums.Count() <= 1)
                    return 0;
                return Math.Sqrt(nums.Sum(x => Math.Pow(Convert.ToDouble(x) - Convert.ToDouble(monthl_avg_demand), 2)) / (nums.Count() - 1));
            }
            else
            {
                var nums = pickbilllist.Where(i => i.ItemNum == itemNum).Select(a =>a.QtyChange);
                if (nums.Count() <= 1)
                    return 0;
                return Math.Sqrt(nums.Sum(x => Math.Pow(Convert.ToDouble(x) - Convert.ToDouble(monthl_avg_demand), 2)) / (nums.Count() - 1));
            }
        }

        /// <summary>
        /// 获取指定日期在为一年中为第几周
        /// </summary>
        /// <param name="dt">指定时间</param>
        /// <reutrn>返回第几周</reutrn>
        public static int GetWeekOfYear(DateTime dt)
        {
            System.Globalization.GregorianCalendar gc = new System.Globalization.GregorianCalendar();
            int weekOfYear = gc.GetWeekOfYear(dt, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Monday);
            return weekOfYear;
        }

        //获取上周开始时间
        public static DateTime getPreWeekStartTime()
        {
            var weekday = (int)DateTime.Now.DayOfWeek;
            return Convert.ToDateTime(DateTime.Now.AddDays(-7 - weekday + 1).ToString("yyyy-MM-dd 00:00:00.000"));
        }
        //获取上周结束时间
        public static DateTime getPreWeekEndTime()
        {
            int weekday = (int)DateTime.Now.DayOfWeek;
            return Convert.ToDateTime(DateTime.Now.AddDays(weekday - 7 + 1).ToString("yyyy-MM-dd 23:59:59.000"));
        }
        /// <summary>
        /// 获取上个月开始时间
        /// </summary>
        /// <param name="months"></param>
        /// <returns></returns>
        public static DateTime getPreMonthStartTime()
        {
            return Convert.ToDateTime(DateTime.Now.AddMonths(-1).AddDays(1 - DateTime.Now.Day).ToString("yyyy-MM-dd 00:00:00.000"));
        }
        /// <summary>
        /// 获取上月结束时间
        /// </summary>
        /// <param name="months"></param>
        /// <returns></returns>
        public static DateTime getPreMonthEndTime()
        {
            return Convert.ToDateTime(DateTime.Now.AddDays(-DateTime.Now.Day).ToString("yyyy-MM-dd 23:59:59.000"));
        }

        /// <summary>
        /// 获取前后某个，整数月开始时间
        /// </summary>
        /// <param name="months">正数表示后多少个月的第一天，负数为前多少个月第一天</param>
        /// <returns></returns>
        public static DateTime getMonthStartTime(int months)
        {
            return getPreMonthStartTime().AddMonths(months + 1);
        }
        /// <summary>
        /// 获取前后某个，整数月结束时间
        /// </summary>
        /// <param name="months">正数表示后多少个月的第一天，负数为前多少个月第一天</param>
        /// <returns></returns>
        public static DateTime getMonthEndTime(int months)
        {
            return getPreMonthEndTime().AddMonths(months + 1);
        }

        /// <summary>
        /// 获取未来几个月PlanMonth
        /// </summary>
        /// <param name="monthCount"></param>
        /// <returns></returns>
        public List<string> GetPlanMonth(int monthCount)
        {
            List<string> result=new List<string>();
            for(int i=0;i< monthCount; i++)
            {
                var months = DateTime.Now.AddMonths(i);
                result.Add($"{months.Year}-{months.Month.ToString("00")}");
            }
            return result;
        }
        /// <summary>
        /// 获取前面几个月PlanMonth
        /// </summary>
        /// <param name="monthCount"></param>
        /// <returns></returns>
        public List<string> GetPrePlanMonth(int monthCount)
        {
            List<string> result = new List<string>();
            for (int i = 0; i < monthCount; i++)
            {
                var months = DateTime.Now.AddMonths(-i);
                result.Add($"{months.Year}-{months.Month.ToString("00")}");
            }
            return result;
        }

        public void AsyncItemStockFromWMS(List<b_bom_pretreatment> bom_Pretreatments)
        {
            //产品编码
            var itemList = bom_Pretreatments.Select(a => a.item_number).Distinct().ToList();
            List<string> itemChildList = new List<string>();
            itemChildList.AddRange(itemList);
            if (!itemChildList.Any())
            {
                return;
            }
            List<string> locationList = new List<string> { "1000", "1001", "5008", "8000", "8001" };
            //取出WMS物料记录
            var stockList = _invMaster.Select(a => a.Domain == param.factoryId.ToString() && locationList.Contains(a.Location) && a.IsActive && itemChildList.Distinct().Contains(a.ItemNum));
            //WMS物料记录汇总
            var groupList = stockList.
                GroupBy(m => new { m.ItemNum }).
                Select(a => new { ItemNum = a.Key.ItemNum, Qty = a.Sum(c => c.AvailStatusQty.GetValueOrDefault() + c.Assay.GetValueOrDefault()) }).ToList();


            var itemNums = groupList.Select(b => b.ItemNum).ToList();//需要处理的dop物料编码集合
            //根据WMS物料，取出DOP物料数据
            var items = _mysql_ic_item.GetListAsync(a => itemNums.Contains(a.number) && a.factory_id == param.factoryId && a.company_id == param.company_id).Result;


            var itemIds = items.Select(b => b.Id).ToList();//需要处理的dop物料id集合
            List<ic_item_stock> mysqlStock = _mysql_ic_item_stock.GetListAsync(a => itemIds.Contains(a.icitem_id) && a.factory_id == param.factoryId && a.company_id == param.company_id).Result;
            List<ic_item_stock> needAddList = new List<ic_item_stock>();

            foreach (var stockWMS in groupList)
            {
                var num = items.Find(x => x.number == stockWMS.ItemNum);
                if (num != null)
                {
                    var item = mysqlStock.Find(a => a.icitem_id == num.Id);
                    if (item != null)
                    {
                        item.sqty = groupList.First(a => a.ItemNum == num.number).Qty;
                    }
                    else
                    {
                        ic_item_stock stock = new ic_item_stock();
                        stock.GenerateNewId(help.NextId());
                        stock.tenant_id = param.company_id;
                        stock.factory_id = param.factoryId;
                        stock.company_id = param.company_id;
                        stock.icitem_id = num.Id;
                        stock.icitem_number = num.number;
                        stock.icitem_name = num.name;
                        stock.sqty = groupList.First(a => a.ItemNum == num.number).Qty;
                        needAddList.Add(stock);
                    }
                }
            }
            if (needAddList.Count > 0)
            {
                _businessDbContext.BulkInsert(needAddList);
            }
            _businessDbContext.BulkUpdate(mysqlStock);
        }
    }
}