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

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

namespace Business.ResourceExamineManagement
{
    public class CalcBomViewAppService : ApplicationService
    {
        /// <summary>
        /// 资源检查入参
        /// </summary>
        public SeorderentryDto param = new SeorderentryDto();

        public List<ICItemLeadTimeDto> leadTimeList = new List<ICItemLeadTimeDto>();
        public List<mo_srm_purchase> supplierList = new List<mo_srm_purchase>();

        public List<SRMPRDto> SRMPRDtoList = new List<SRMPRDto>();
        public List<mo_mes_oorder> orderList = new List<mo_mes_oorder>();

        public List<mo_mes_morder> mordersList = new List<mo_mes_morder>();
        public List<mo_mes_morder> mordersInsertList = new List<mo_mes_morder>();
        public List<mo_mes_moentry> moentriesList = new List<mo_mes_moentry>();
        public List<mo_mes_moentry> moentriesInsertList = new List<mo_mes_moentry>();
        public List<mo_mes_mooccupy> mooccupyAllList = new List<mo_mes_mooccupy>();
        public List<mo_mes_mooccupy> mooccupyAllInsertList = new List<mo_mes_mooccupy>();
        public List<mo_ic_item> ic_item_List = new List<mo_ic_item>();
        public List<mo_srm_po_list> srm_Po_Lists = new List<mo_srm_po_list>();
        public List<mo_srm_po_occupy> srm_Po_Occupies = new List<mo_srm_po_occupy>();
        public List<mo_srm_pr_main> srm_Pr_Mains = new List<mo_srm_pr_main>();
        public List<mo_srm_po_occupy> srm_Po_OccupiesInsert = new List<mo_srm_po_occupy>();
        public List<scm_jhjh_jqDto> scm_Jhjh_Jqs = new List<scm_jhjh_jqDto>();
        public List<scm_shdzbDto> scm_Shdzbs = new List<scm_shdzbDto>();
        public List<scm_shdzbDto> scm_ShdzbJYs = new List<scm_shdzbDto>();
        public List<mo_ic_item_stockoccupy> newStockOccList = new List<mo_ic_item_stockoccupy>();

        public crm_seorder seorder = new crm_seorder();

        public mes_morder mes_morder = new mes_morder();
        public List<mo_srm_pr_main> quarter_srm_pr_mains = new List<mo_srm_pr_main>();

        public DateTime quarter_starttime;
        public DateTime quarter_endtime;
        public List<string> GenerateMoList = new List<string>();

        /// <summary>
        /// 是否正排
        /// </summary>
        public bool IsStraight = false;

        /// <summary>
        /// 工单类型
        /// </summary>
        public string morder_type;

        SnowFlake help = new SnowFlake();

        /// <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>();

        /// <summary>
        /// 工单App
        /// </summary>
        private readonly MorderAppService _morderAppService;

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

        /// <summary>
        /// 在途检查
        /// </summary>
        private readonly PurchaseOrderAppService _purchaseOrderAppService;

        private readonly SerialNumberAppService _serialNumberAppService;

        Random rnd = new Random();

        public decimal ProductionTimeDay;
        //是否虚拟计算
        public bool LongPeriod = false;
        //是否虚拟计算
        public bool ScheduleAgreement = false;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="morderAppService"></param>
        public CalcBomViewAppService(MorderAppService morderAppService,
            ProductExamineAppService productExamineAppService,
            PurchaseOrderAppService purchaseOrderAppService,
            SerialNumberAppService serialNumberAppService)
        {
            _morderAppService = morderAppService;
            _productExamineAppService = productExamineAppService;
            _purchaseOrderAppService = purchaseOrderAppService;
            _serialNumberAppService = serialNumberAppService;
        }

        /// <summary>
        /// 计算物料库存量
        /// </summary>
        /// <param name="returnlist"></param>
        public void BomStock(List<BomChildExamineDto> returnlist, List<mo_ic_item_stock> _ic_item_stock, long bangid)
        {
            returnlist = returnlist.OrderBy(s => s.num_order).ToList();
            //获取当前工厂下物料库存数据
            List<long> icitemIds = returnlist.Select(c => c.item_id).ToList();
            var stocklist = _ic_item_stock.Where(p => p.factory_id == param.factoryId && p.bang_id == bangid && icitemIds.Contains(p.icitem_id)).ToList();
            //计算剩余库存
            foreach (var item in returnlist)
            {
                if (item.erp_cls == 4)//虚拟件不计算
                {
                    continue;
                }
                //非虚拟件
                //当前物料的库存数量
                decimal stockQty = stocklist.Where(s => s.icitem_id == item.item_id).Sum(p => p.sqty.GetValueOrDefault());
                item.sqty = stockQty;
            }
        }


        /// <summary>
        /// Bom平铺物料情况计算
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="bangid"></param>
        /// <param name="count"></param>
        /// <param name="plan_date"></param>
        /// <param name="checkflag">是否生成工单、委外、采购</param>
        public void CalcView(List<BomChildExamineDto> returnlist, long bangid, decimal count, DateTime
            ? plan_date, List<mo_ic_item_stockoccupy> sklist, crm_seorderentry sentrys, List<mo_ic_item> icitemlist)
        {
            ProductionTimeDay = 0;
            //第一级
            returnlist = returnlist.OrderBy(s => s.num_order).ToList();
            var level1Dto = returnlist[0];
            //第二级
            var childList = returnlist.Where(s => s.parent_id == level1Dto.fid && s.type == 0).OrderBy(s => s.num_order).ToList();

            //1.如果主料够的时候，不需要显示替代料的平铺视图，如果主料不够，显示替代料的平铺视图。
            //2.替代策略和替代方式，影响到的是甲乙组概念，替代按主料有限，取代按组的优先级。A与B的替代，则A和B各自会存在一个组。
            List<long> calcIds = new List<long>();
            //先处理下最顶级的产品需要数量

            level1Dto.needCount = level1Dto.qty * count;
            //直接占用库存，缺料就生成采购
            mo_ic_item_stockoccupy itemStockoccupyDto = new mo_ic_item_stockoccupy();
            itemStockoccupyDto.bang_id = bangid;
            itemStockoccupyDto.icitem_id = level1Dto.item_id;
            itemStockoccupyDto.icitem_number = level1Dto.item_number;
            itemStockoccupyDto.item_no = level1Dto.num;
            itemStockoccupyDto.occupy_time = DateTime.Now;
            if (sentrys != null)
            {
                itemStockoccupyDto.orderentry_id = sentrys.Id;
                itemStockoccupyDto.order_id = sentrys.seorder_id;
            }
            if (mes_morder != null)
            {
                itemStockoccupyDto.morder_id = mes_morder.Id;
                itemStockoccupyDto.morder_mo = mes_morder.morder_no;
            }
            if (param.checkflag && morder_type == MorderEnum.XsMorder)
            {
                //找到当前物料的占用记录
                var itemSockoccupy = sklist.Where(s => s.icitem_id == level1Dto.item_id && s.bang_id == bangid).ToList();
                //计算库存减去占用
                level1Dto.sqty -= itemSockoccupy.Sum(s => s.quantity);
                level1Dto.sqty = level1Dto.sqty < 0 ? 0 : level1Dto.sqty;
                level1Dto.lack_qty = level1Dto.needCount - level1Dto.sqty;
                level1Dto.lack_qty = level1Dto.lack_qty < 0 ? 0 : level1Dto.lack_qty;
                //level1Dto.needCount = level1Dto.lack_qty;
                if (level1Dto.sqty != 0)
                {
                    if (level1Dto.lack_qty > 0)
                    {
                        level1Dto.use_qty = level1Dto.sqty;
                    }
                    else
                    {
                        level1Dto.use_qty = level1Dto.needCount;
                    }
                    itemStockoccupyDto.quantity = level1Dto.sqty;
                    sklist.Add(itemStockoccupyDto);
                    newStockOccList.Add(itemStockoccupyDto);
                }
            }
            else
            {
                level1Dto.lack_qty = level1Dto.needCount;
                level1Dto.sqty = 0;
            }
            level1Dto.self_lack_qty = level1Dto.lack_qty;

            level1Dto.is_use = true;
            //获取物料详情
            if (level1Dto.lack_qty > 0)
            {
                var ic_item = icitemlist.Find(s => s.mysql_id == level1Dto.item_id);
                _morderAppService.mo_Mes_Morders = mordersList;//工单
                _morderAppService.mo_Mes_Moentry = moentriesList;//工单子表
                _morderAppService.mo_Mes_Mooccupies = mooccupyAllList;//工单占用
                _morderAppService.param = param;
                List<mo_mes_mooccupy> mooccupylist = new List<mo_mes_mooccupy>();
                if (param.checkflag && morder_type == MorderEnum.XsMorder && !LongPeriod)
                {
                    //工单检查无需检查在制
                    mooccupylist = _morderAppService.CheckMorder(level1Dto.item_number, level1Dto.lack_qty, plan_date.GetValueOrDefault(), sentrys, ic_item, bangid);
                }

                if (mooccupylist.Any())
                {
                    mooccupyAllList.AddRange(mooccupylist);
                    mooccupyAllInsertList.AddRange(mooccupylist);
                    //在制占用明细
                    level1Dto.mo_occupy_list = new List<mo_occupy>();
                    mooccupylist.ForEach(s =>
                    {
                        mo_occupy mooc = new mo_occupy();
                        mooc.id = s.Id;
                        mooc.moo_mo = s.moo_mo;
                        mooc.moo_stime = s.moo_ctime;
                        mooc.moo_etime = s.moo_etime;
                        mooc.moo_qty = s.moo_qty;
                        level1Dto.mo_occupy_list.Add(mooc);
                    });
                }

                decimal moo_qty = mooccupylist.Sum(s => s.moo_qty.GetValueOrDefault());
                level1Dto.mo_qty = moo_qty;

                if (moo_qty == level1Dto.lack_qty)
                {
                    //在制完全足够
                    level1Dto.lack_qty = 0;
                    level1Dto.satisfy_time = mooccupylist[0].moo_etime;
                    level1Dto.kitting_time = level1Dto.satisfy_time;
                    sentrys.sys_capacity_date = level1Dto.kitting_time.GetValueOrDefault().AddDays(1);
                    if (ic_item != null)
                    {
                        double insLT = (double)Math.Ceiling(ic_item.self_inspection_date.GetValueOrDefault());
                        sentrys.sys_capacity_date = sentrys.sys_capacity_date.GetValueOrDefault().AddDays(insLT);
                    }
                    level1Dto.stock_state = 1;
                    level1Dto.kitting_state = 3;
                    return;
                }
                else
                {
                    //占用不够,占用后减少缺料数量
                    //level1Dto.lack_qty -= moo_qty;
                    //level1Dto.needCount = level1Dto.lack_qty;
                    //平铺需要数量
                    CaclMaterialShortage(returnlist);
                    //先设定在制的齐套时间
                    //level1Dto.satisfy_time = mooccupylist[0]?.moo_etime;
                    level1Dto.stock_state = 0;
                    _productExamineAppService.prodLines = prodLines;
                    _productExamineAppService.routingOps = routingOps;
                    _productExamineAppService.periodSequences = periodSequences;
                    _productExamineAppService.calendarWorks = calendarWorks;
                    _productExamineAppService.qualityLineWorks = qualityLineWorks;
                    _productExamineAppService.holidays = holidays;
                    if (param.checkflag || (!param.checkflag && param.checkPlan))
                    {
                        //根据成品属性来判断是自制还是委外还是外购，需要考虑这种场景
                        if (level1Dto.erp_cls == 1 && param.checkflag)
                        {
                            level1Dto.make_qty = level1Dto.lack_qty - level1Dto.mo_qty;
                            ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                            {
                                ItemNum = level1Dto.item_number,
                                PlanStart = plan_date.GetValueOrDefault(),
                                QtyOrd = level1Dto.make_qty,
                                Domain = param.factoryId.ToString()
                            };
                            int make_time = _productExamineAppService.ProductTime(prodExamine);
                            //设置成品的生产时长为子物料的提前准备期
                            string order_mo = "";
                            if (GenerateMoList.Any())
                            {
                                order_mo = GenerateMoList[0];
                                GenerateMoList.Remove(order_mo);
                            }
                            //生成主工单
                            GenerateMorderDto generateMorderDto = new GenerateMorderDto()
                            {
                                seorderentry = sentrys,
                                seorder = seorder,
                                ic_Item = ic_item,
                                BomNumber = level1Dto.bom_number,
                                version = level1Dto.version,
                                number = level1Dto.item_number,
                                Quantity = level1Dto.make_qty,
                                morder_type = morder_type,
                                work_order_type = MorderEnum.CgMorder,
                                morder_state = MorderEnum.Initial_state,//MorderEnum.Initial_state,按要求，变成未发布工单，在周计划发布那里发布工单
                                bang_id = bangid,
                                morder_no = order_mo
                            };
                            CreateMainOrder(generateMorderDto, level1Dto, childList, returnlist, bangid, plan_date, sklist, sentrys, icitemlist, make_time);
                        }
                        else if (level1Dto.erp_cls == 3)
                        {
                            //根据货源清单配额查找对应在途
                            var supplist = supplierList.Where(s => s.icitem_id == level1Dto.item_id && s.quota_rate.GetValueOrDefault() > 0).ToList();
                            if (!supplist.Any())
                            {
                                level1Dto.stock_state = 99;
                                level1Dto.kitting_state = 5;
                                level1Dto.kitting_time = plan_date.GetValueOrDefault().AddDays(-1);
                                return;
                            }
                            var maxLeadTime = supplist.Max(x => x.lead_time.GetValueOrDefault());

                            var wwPlan_data = plan_date.GetValueOrDefault().AddDays(-(int)maxLeadTime);
                            foreach (var sup in supplist)
                            {
                                decimal suplack_qty = Math.Ceiling(level1Dto.lack_qty * sup.quota_rate.GetValueOrDefault() / 100);
                                //先找在途
                                decimal occqty = CalcInTransit(sentrys, level1Dto, bangid, plan_date.GetValueOrDefault(), suplack_qty, sup.supplier_id.GetValueOrDefault());
                                if (level1Dto.lack_qty - occqty > 0)
                                {
                                    decimal itemPRQty = srm_Pr_Mains.Where(x => x.icitem_id.Value == level1Dto.item_id && x.pr_sarrive_date <= plan_date).Sum(y => y.pr_aqty.GetValueOrDefault());
                                    if (itemPRQty < level1Dto.lack_qty - occqty)
                                    {
                                        //level1Dto.lack_qty = level1Dto.lack_qty - itemPRQty;
                                        decimal lack_qty = level1Dto.lack_qty - itemPRQty;
                                        //采购申请
                                        PackageSRMPR(level1Dto, bangid, sentrys, plan_date, lack_qty, null);
                                    }
                                }
                            }
                            //先找在途
                            //decimal occqty = CalcInTransit(sentrys, level1Dto, bangid, plan_date.GetValueOrDefault(), level1Dto.lack_qty, null);
                            //if (level1Dto.lack_qty - occqty > 0)
                            //{
                            //    decimal itemPRQty = srm_Pr_Mains.Where(x => x.icitem_id.Value == level1Dto.item_id && x.pr_sarrive_date <= plan_date).Sum(y => y.pr_aqty.GetValueOrDefault());
                            //    if (itemPRQty < level1Dto.lack_qty - occqty)
                            //    {
                            //        //level1Dto.lack_qty = level1Dto.lack_qty - itemPRQty;
                            //        decimal lack_qty = level1Dto.lack_qty - itemPRQty;
                            //        //采购申请
                            //        PackageSRMPR(level1Dto, bangid, sentrys, plan_date, lack_qty, null);
                            //    }
                            //}
                        }
                        else if (level1Dto.erp_cls == 2)
                        {
                            //先找在途
                            decimal occqty = CalcInTransit(sentrys, level1Dto, bangid, plan_date.GetValueOrDefault(), level1Dto.lack_qty, null);
                            decimal lack_qty = level1Dto.lack_qty - occqty;
                            if (lack_qty > 0)
                            {
                                //1.先生成委外工单。
                                var mesorder = CreateMesOOder(level1Dto, lack_qty, param.company_id, param.factoryId, bangid, leadTimeList, supplierList, plan_date.Value);
                                mesorder.ooentry_etime = plan_date.GetValueOrDefault().AddDays(-1);
                                var srmprDto = PackageSRMPR(level1Dto, bangid, sentrys, plan_date, lack_qty, null);
                                mesorder.ooentry_stime = plan_date.GetValueOrDefault().AddDays(-srmprDto.totalLeadTime.GetValueOrDefault());

                                //先计算末级数据的齐套时间。
                                if (childList.Count > 0)//按业务要求，委外件向下展开子料
                                {
                                    MatterTileDevelop(level1Dto, childList, returnlist, sklist, bangid, mesorder.ooentry_stime, sentrys, icitemlist);

                                    level1Dto.kitting_time = childList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());//加上物料的采购提前期
                                    if (IsStraight)
                                    {
                                        mesorder.ooentry_stime = childList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(1);
                                        mesorder.ooentry_etime = mesorder.ooentry_stime.GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());
                                    }
                                }

                                level1Dto.subcontracting_qty = lack_qty;
                                level1Dto.subcontracting_list = new List<ooder>();
                                ooder oo = new ooder();
                                oo.Id = mesorder.Id;
                                oo.morder_production_number = mesorder.morder_production_number;
                                oo.production_unit = mesorder.production_unit;
                                oo.production_unit_code = mesorder.production_unit_code;
                                oo.ooentry_prdname = mesorder.ooentry_prdname;
                                oo.ooentry_stime = mesorder.ooentry_stime;
                                oo.ooentry_etime = mesorder.ooentry_etime;
                                oo.oorder_date = mesorder.oorder_date;
                                oo.oorder_no = mesorder.oorder_no;
                                level1Dto.subcontracting_list.Add(oo);
                                orderList.Add(mesorder);
                            }
                        }
                        else
                        {
                            MatterTileDevelop(level1Dto, childList, returnlist, sklist, bangid, plan_date, sentrys, icitemlist);
                        }
                    }
                    else
                    {
                        MatterTileDevelop(level1Dto, childList, returnlist, sklist, bangid, plan_date, sentrys, icitemlist);
                    }
                    //CalcLevelMakeTime(returnlist);
                }
            }
            else
            {
                level1Dto.is_use = true;
                level1Dto.kitting_time = DateTime.Now;
                level1Dto.lack_qty = 0;
                level1Dto.satisfy_time = DateTime.Now;
                if (sentrys != null)
                {
                    //如果库存足够，则默认增加3天。
                    sentrys.sys_capacity_date = level1Dto.satisfy_time.Value.AddDays(3);
                }
                level1Dto.stock_state = 1;
                level1Dto.kitting_state = 1;
                return;
            }
        }

        /// <summary>
        /// 生成主工单
        /// </summary>
        public void CreateMainOrder(GenerateMorderDto generateMorderDto, BomChildExamineDto level1Dto, List<BomChildExamineDto> childList, List<BomChildExamineDto> returnlist, long bangid, DateTime
            ? plan_date, List<mo_ic_item_stockoccupy> sklist, crm_seorderentry sentrys, List<mo_ic_item> icitemlist, int make_time)
        {
            //生成主工单
            _morderAppService.prodLines = prodLines;
            _morderAppService.routingOps = routingOps;
            _morderAppService.periodSequences = periodSequences;
            _morderAppService.calendarWorks = calendarWorks;
            _morderAppService.qualityLineWorks = qualityLineWorks;
            _morderAppService.holidays = holidays;
            _morderAppService.param = param;
            Mes_MorderDto mes_MorderDto = _morderAppService.GenerateMorder(generateMorderDto);
            //这里更新产品得满足时间。
            if (mes_MorderDto != null)
            {
                //主工单最后计算满足日期
                var mes_Morders = mes_MorderDto.mes_Morders.Where(x => x.parent_id == null).FirstOrDefault();
                if (mes_Morders != null)
                {
                    mes_morder = ObjectMapper.Map<mo_mes_morder, mes_morder>(mes_Morders);
                    var plan = icitemlist.Find(x => x.mysql_id == level1Dto.item_id);
                    //结束日期=开始时间+生产时长+自检提前期+入库提前期+发运提前期；
                    decimal LeadTime = 0;
                    if (plan != null)
                    {
                        //减去提前期
                        //LeadTime = plan.self_inspection_date.GetValueOrDefault() + plan.Warehousing_date.GetValueOrDefault() + plan.Shipping_date.GetValueOrDefault();
                        LeadTime = plan.self_inspection_date.GetValueOrDefault() + plan.PurLT;
                    }
                    mes_Morders.moentry_sys_etime = plan_date.GetValueOrDefault().AddDays(-(int)Math.Ceiling(LeadTime));

                    mes_Morders.moentry_sys_stime = mes_Morders.moentry_sys_etime.GetValueOrDefault().AddDays(-(make_time - 1));
                    MatterTileDevelop(level1Dto, childList, returnlist, sklist, bangid, mes_Morders.moentry_sys_stime, sentrys, icitemlist);
                    if (IsStraight)
                    {
                        if (childList.Any())
                        {
                            //正排
                            mes_Morders.moentry_sys_stime = childList.Max(s => s.kitting_time.GetValueOrDefault()).AddDays(1).Date;//数据齐套完成后隔天开始生产；
                        }
                        mes_Morders.moentry_sys_etime = mes_Morders.moentry_sys_stime.GetValueOrDefault().AddDays(make_time);
                    }
                    if (mes_Morders.moentry_sys_etime < DateTime.Now.Date)
                    {
                        mes_Morders.moentry_sys_etime = DateTime.Now.Date;
                    }
                    if (mes_Morders.moentry_sys_stime < DateTime.Now.Date)
                    {
                        mes_Morders.moentry_sys_stime = DateTime.Now.Date;
                    }
                    if (!string.IsNullOrEmpty(mes_Morders.bom_number))
                    {
                        if (childList.Any())
                        {
                            mes_Morders.mat_start_date = childList.Max(s => s.kitting_time.GetValueOrDefault()).AddDays(1).Date;//数据齐套完成后隔天开始生产；
                        }
                        else
                        {
                            mes_Morders.mat_start_date = mes_Morders.moentry_sys_stime;
                        }
                        mes_Morders.mat_end_date = mes_Morders.mat_start_date.GetValueOrDefault().AddDays(make_time);

                        /*ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                        {
                            ItemNum = mes_Morders.bom_number,
                            PlanStart = mes_Morders.moentry_sys_stime.Value,
                            QtyOrd = (int)mes_Morders.morder_production_number.Value
                        };
                        _productExamineAppService.prodLines = prodLines;
                        _productExamineAppService.routingOps = routingOps;
                        _productExamineAppService.periodSequences = periodSequences;
                        _productExamineAppService.calendarWorks = calendarWorks;
                        _productExamineAppService.qualityLineWorks = qualityLineWorks;
                        _productExamineAppService.holidays = holidays;

                        
                        var ProductiveDate = _productExamineAppService.ProductiveExamine(prodExamine);

                        mes_Morders.moentry_sys_etime = LeadTime;
                        TimeSpan span = ProductiveDate - mes_Morders.moentry_sys_stime.Value;
                        mes_Morders.morder_need_time = (decimal)span.TotalMinutes;*/
                    }
                    //满足资源检查的时间需加上提前期
                    if (childList.Any())
                    {
                        level1Dto.satisfy_time = childList.Max(s => s.kitting_time.GetValueOrDefault()).AddDays(make_time).Date;
                    }
                    if (sentrys != null)
                    {
                        sentrys.sys_capacity_date = level1Dto.satisfy_time.GetValueOrDefault().AddDays(1);
                        if (plan != null)
                        {
                            double insLT = (double)Math.Ceiling(plan.self_inspection_date.GetValueOrDefault());
                            sentrys.sys_capacity_date = sentrys.sys_capacity_date.GetValueOrDefault().AddDays(insLT);
                        }
                    }
                    level1Dto.make_list = new List<moorder>();
                    mes_MorderDto.mes_Morders.ForEach(me =>
                    {
                        moorder mo = new moorder();
                        mo.Id = me.Id;
                        mo.moentry_stime = me.moentry_stime;
                        mo.moentry_etime = me.moentry_etime;
                        mo.moentry_wrkcname = me.moentry_wrkcname;
                        mo.moentry_sys_stime = me.moentry_sys_stime;
                        mo.moentry_sys_etime = me.moentry_sys_etime;
                        mo.moentry_prdname = me.moentry_prdname;
                        mo.morder_need_time = me.morder_need_time;
                        mo.morder_no = me.morder_no;
                        mo.morder_production_number = me.morder_production_number;
                        mo.need_number = me.need_number;
                        mo.reality_end_time = me.reality_end_time;
                        mo.reality_start_time = me.reality_start_time;
                        level1Dto.make_list.Add(mo);
                    });
                    //批量保存 后期考虑子工单
                    mordersList.AddRange(mes_MorderDto.mes_Morders);
                    mordersInsertList.AddRange(mes_MorderDto.mes_Morders);
                    moentriesList.AddRange(mes_MorderDto.mes_Moentries);
                    moentriesInsertList.AddRange(mes_MorderDto.mes_Moentries);
                }
            }
        }


        /// <summary>
        /// 物料计算
        /// </summary>
        /// <param name="level1Dto"></param>
        /// <param name="childList"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="bangid"></param>
        /// <param name="plan_date"></param>
        /// <param name="sentrys"></param>
        /// <param name="icitemlist"></param>
        public void MatterTileDevelop(BomChildExamineDto level1Dto, List<BomChildExamineDto> childList, List<BomChildExamineDto> returnlist, List<mo_ic_item_stockoccupy> sklist, long bangid, DateTime
            ? plan_date, crm_seorderentry sentrys, List<mo_ic_item> icitemlist)
        {
            //这是从上往下展开计算缺料和可制
            CaleLackItem(level1Dto, childList, returnlist, sklist, bangid);
            //level1Dto.kz = childList.Min(s => s.kz);//得到最小可制数量。
            //再加个循环，来根据替代关系里的检查结果，根据规则明确使用和生成占用关系。
            List<long> childidList = new List<long>();
            CalcIcitem(childList, returnlist, bangid, sklist, plan_date, icitemlist, sentrys, childidList);
            if (childList.Count>0)
            {
                level1Dto.kitting_time = childList.Max(x => x.kitting_time.GetValueOrDefault());
            }
        }


        /// <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="parent"></param>
        /// <param name="bzlist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sockoccupyList"></param>
        public void CaleLackItem(BomChildExamineDto parent, List<BomChildExamineDto> bzlist, List<BomChildExamineDto> returnlist, List<mo_ic_item_stockoccupy> sockoccupyList, long bangid)
        {
            //从第二级开始循环
            foreach (var item in bzlist)
            {
                var childList = returnlist.Where(s => s.parent_id == item.fid && s.type == 0).ToList();

                //根据占用情况计算库存
                Calczykc(item, parent, sockoccupyList, bangid);
                //如果有子集，则丢入循环，判断下库存可制等信息。
                CaleLackItem(item, childList, returnlist, sockoccupyList, bangid);
            }
        }

        /// <summary>
        /// 根据每个物料来实时计算占用情况
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sockoccupyList"></param>
        public void Calczykc(BomChildExamineDto item, BomChildExamineDto parent, List<mo_ic_item_stockoccupy> sockoccupyList, long bangid)
        {
            //找到当前物料的占用记录
            var itemSockoccupy = sockoccupyList.Where(s => s.icitem_id == item.item_id && s.bang_id == bangid).ToList();
            //计算库存减去占用
            item.sqty -= itemSockoccupy.Sum(s => s.quantity);
            //如果库存
            item.sqty = item.sqty < 0 ? 0 : item.sqty;
            if (parent.stock_state == 1 || parent.stock_state == -1)
            {
                item.stock_state = parent.stock_state;
                item.kitting_state= 1;
                item.lack_qty = 0;
                item.self_lack_qty = 0;
            }
            else
            {
                //判断缺料数量
                item.self_lack_qty = Math.Ceiling((parent.lack_qty - parent.mo_qty - parent.purchase_occupy_qty) * item.qty * (1 + (item.scrap.GetValueOrDefault() / 100)) + item.wastage.GetValueOrDefault());
                item.lack_qty = item.self_lack_qty - item.sqty;
                item.lack_qty = item.lack_qty < 0 ? 0 : item.lack_qty;
                //判断状态
                item.stock_state = item.lack_qty > 0 ? 0 : 1;
                //判断状态
                item.kitting_state = item.lack_qty > 0 ? 5 : 1;
            }
        }

        /// <summary>
        /// 循环计算物料情况
        /// </summary>
        /// <param name="childList"></param>
        /// <param name="returnlist"></param>
        /// <param name="bangid"></param>
        /// <param name="orderid"></param>
        /// <param name="input"></param>
        /// <param name="sklist"></param>
        /// <param name="plan_date"></param>
        public void CalcIcitem(List<BomChildExamineDto> childList, List<BomChildExamineDto> returnlist, long bangid, List<mo_ic_item_stockoccupy> sklist, DateTime
            ? plan_date, List<mo_ic_item> icitemlist, crm_seorderentry sentrys, List<long> childidList)
        {
            foreach (var item in childList)
            {
                var parent = returnlist.Find(s => s.fid == item.parent_id);
                if (parent.erp_cls == 1 && parent.level!=1 && !param.writeNum)
                {
                    continue;
                }
                if (parent.stock_state == 0)
                {
                    if (childidList.Contains(item.bom_child_id.GetValueOrDefault()))
                    {
                        continue;
                    }
                    if (item.haveicsubs == 1)
                    {
                        //如果有替代关系，根据群组来明确使用哪个群组的替代料。按整批和混用逻辑来算
                        //如果有群组替代，就移除掉被检查过的记录 item.icitem_ids
                        //通过替代群组代码，将替代群组物料进行绑定。
                        childidList.AddRange(returnlist.Where(s => s.substitute_code == item.substitute_code).Select(d => d.bom_child_id.GetValueOrDefault()));
                        CalcStrategy(item, returnlist, bangid, sklist, plan_date, icitemlist, sentrys, childidList);
                    }
                    else
                    {
                        Calczykc(item, parent, newStockOccList, bangid);

                        //直接占用库存，缺料就生成采购
                        mo_ic_item_stockoccupy itemStockoccupyDto = new mo_ic_item_stockoccupy();
                        itemStockoccupyDto.bang_id = bangid;
                        itemStockoccupyDto.icitem_id = item.item_id;
                        itemStockoccupyDto.icitem_number = item.item_number;
                        itemStockoccupyDto.item_no = item.num;
                        itemStockoccupyDto.occupy_time = DateTime.Now;
                        item.kitting_time = DateTime.Now;
                        if (sentrys != null)
                        {
                            itemStockoccupyDto.orderentry_id = sentrys.Id;
                            itemStockoccupyDto.order_id = sentrys.seorder_id;
                        }
                        if (mes_morder != null)
                        {
                            itemStockoccupyDto.morder_id = mes_morder.Id;
                            itemStockoccupyDto.morder_mo = mes_morder.morder_no;
                        }
                        item.is_use = true;
                        StartProcessing(item, icitemlist, returnlist, plan_date, sentrys, sklist, itemStockoccupyDto, bangid, childidList);
                    }
                }
            }
        }

        /// <summary>
        /// 针对缺料开始进行处理
        /// </summary>
        /// <param name="item"></param>
        /// <param name="icitemlist"></param>
        /// <param name="returnlist"></param>
        /// <param name="plan_date"></param>
        /// <param name="sentrys"></param>
        /// <param name="sklist"></param>
        /// <param name="itemStockoccupyDto"></param>
        /// <param name="bangid"></param>
        /// <param name="input"></param>
        public void StartProcessing(BomChildExamineDto item, List<mo_ic_item> icitemlist, List<BomChildExamineDto> returnlist, DateTime
            ? plan_date, crm_seorderentry sentrys, List<mo_ic_item_stockoccupy> sklist, mo_ic_item_stockoccupy itemStockoccupyDto, long bangid, List<long> childidList)
        {
            var parent = returnlist.Find(s => s.fid == item.parent_id);
            if (item.lack_qty > 0)
            {
                if (!param.checkflag && !param.checkPlan)
                {
                    plan_date = DateTime.Now.AddDays(5);
                }
                if (!param.writeNum)
                {
                    plan_date = DateTime.Now.AddDays(-1);
                }
                //item.make_time = parent.make_time.GetValueOrDefault();
                var cilList = returnlist.Where(s => s.parent_id == item.fid && s.type == item.type).OrderBy(k => k.num_order).ToList();
                //如果缺料，占用库存，然后走采购或自制
                if (item.sqty > 0)
                {
                    itemStockoccupyDto.quantity = item.sqty;
                    newStockOccList.Add(itemStockoccupyDto);
                    sklist.Add(itemStockoccupyDto);
                }
                //增加前处理时间
                if (item.clean_leadtime.GetValueOrDefault() != 0)
                {
                    plan_date = plan_date.GetValueOrDefault().AddDays(-(int)Math.Ceiling(item.clean_leadtime.GetValueOrDefault()));
                }
                item.use_qty = item.sqty;
                if (item.erp_cls == 1)
                {
                    var ic_item = icitemlist.Find(s => s.mysql_id == item.item_id);
                    List<mo_mes_mooccupy> mooccupylist = new List<mo_mes_mooccupy>();
                    if ((param.checkflag || param.checkPlan) && !LongPeriod)
                    {
                        mooccupylist = _morderAppService.CheckMorder(item.item_number, item.lack_qty, plan_date.GetValueOrDefault(), sentrys, ic_item, bangid, mes_morder);
                    }
                    decimal moo_qty = mooccupylist.Sum(s => s.moo_qty.GetValueOrDefault());
                    item.mo_qty = moo_qty;
                    item.kitting_time = DateTime.Now;
                    if (mooccupylist.Any())
                    {
                        mooccupyAllList.AddRange(mooccupylist);
                        mooccupyAllInsertList.AddRange(mooccupylist);
                        item.kitting_time = mooccupylist[0].moo_etime;
                        //在制占用明细
                        item.mo_occupy_list = new List<mo_occupy>();
                        mooccupylist.ForEach(s =>
                        {
                            mo_occupy mooc = new mo_occupy();
                            mooc.id = s.Id;
                            mooc.moo_mo = s.moo_mo;
                            mooc.moo_stime = s.moo_ctime;
                            mooc.moo_etime = s.moo_etime;
                            mooc.moo_qty = s.moo_qty;
                            item.mo_occupy_list.Add(mooc);
                        });
                    }
                    if (moo_qty == item.lack_qty)
                    {
                        //在制完全足够
                        item.lack_qty = 0;
                        item.stock_state = 1;
                        item.kitting_state = 3;
                    }
                    //else if (!LongPeriod)
                    //{
                    //    //item.lack_qty -= moo_qty;
                    //    item.make_qty = item.lack_qty - item.mo_qty;
                    //    item.stock_state = 0;
                    //    item.kitting_state = 5;
                    //    item.kitting_time = plan_date.GetValueOrDefault();
                    //}
                    else
                    {
                        //item.lack_qty -= moo_qty;
                        List<string> tsWork = new List<string> { "试制工单", "TCN工单", "返工工单" };
                        //如果是特殊工单，只判断自制件的库存和在制，而不生成自制
                        if (!tsWork.Contains(mes_morder.morder_type))
                        {
                            item.make_qty = item.lack_qty - item.mo_qty;
                            string order_mo = "";
                            if (GenerateMoList.Any())
                            {
                                order_mo = GenerateMoList[0];
                                GenerateMoList.Remove(order_mo);
                            }
                            GenerateMorderDto generateMorderDto = new GenerateMorderDto()
                            {
                                seorderentry = sentrys,
                                seorder = seorder,
                                ic_Item = ic_item,
                                BomNumber = item.bom_number,
                                version = item.version,
                                number = item.item_number,
                                Quantity = item.make_qty,
                                morder_type = morder_type,
                                work_order_type = MorderEnum.CgMorder,
                                morder_state = MorderEnum.Initial_state,
                                ParentId = mes_morder.Id,
                                bang_id = bangid,
                                morder_no = order_mo
                            };
                            Mes_MorderDto mes_MorderDto = _morderAppService.GenerateMorder(generateMorderDto);

                            ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                            {
                                ItemNum = item.item_number,
                                PlanStart = plan_date.GetValueOrDefault(),
                                QtyOrd = item.make_qty,
                                Domain = param.factoryId.ToString()
                            };
                            int make = _productExamineAppService.ProductTime(prodExamine);
                            /*if (make < item.PurLT)
                            {
                                //如果生产时长小于供应提前期，则按供应提前期算
                                make = item.PurLT;
                            }*/

                            if (mes_MorderDto != null)
                            {
                                //主工单最后计算满足日期
                                var mes_Morders = mes_MorderDto.mes_Morders.FirstOrDefault();
                                if (mes_Morders != null)
                                {
                                    var generateMooccupy = _morderAppService.GetMooccupies(sentrys, ic_item, mes_Morders, item.make_qty, bangid);
                                    mooccupyAllList.Add(generateMooccupy);
                                    mooccupyAllInsertList.Add(generateMooccupy);

                                    //子工单生成的检查明细，还是挂接到主工单上。
                                    mes_Morders.moentry_sys_etime = plan_date.GetValueOrDefault().AddDays(-1 - ic_item.PurLT);
                                    mes_Morders.moentry_sys_stime = mes_Morders.moentry_sys_etime.GetValueOrDefault().AddDays(-(make - 1));
                                    item.make_list = new List<moorder>();
                                    mes_MorderDto.mes_Morders.ForEach(me =>
                                    {
                                        moorder mo = new moorder();
                                        mo.Id = me.Id;
                                        mo.moentry_stime = me.moentry_stime;
                                        mo.moentry_etime = me.moentry_etime;
                                        mo.moentry_wrkcname = me.moentry_wrkcname;
                                        mo.moentry_sys_stime = me.moentry_sys_stime;
                                        mo.moentry_sys_etime = me.moentry_sys_etime;
                                        mo.moentry_prdname = me.moentry_prdname;
                                        mo.morder_need_time = me.morder_need_time;
                                        mo.morder_no = me.morder_no;
                                        mo.morder_production_number = me.morder_production_number;
                                        mo.need_number = me.need_number;
                                        mo.reality_end_time = me.reality_end_time;
                                        mo.reality_start_time = me.reality_start_time;
                                        item.make_list.Add(mo);
                                    });
                                    //批量保存 后期考虑子工单
                                    mordersList.AddRange(mes_MorderDto.mes_Morders);
                                    mordersInsertList.AddRange(mes_MorderDto.mes_Morders);
                                    moentriesList.AddRange(mes_MorderDto.mes_Moentries);
                                    moentriesInsertList.AddRange(mes_MorderDto.mes_Moentries);

                                    mes_Morders.mat_start_date = item.kitting_time.GetValueOrDefault().AddDays(1).Date;//数据齐套完成后隔天开始生产；
                                                                                                                       //先计算末级数据的齐套时间。
                                    if (cilList.Count > 0)
                                    {
                                        CalcIcitem(cilList, returnlist, bangid, sklist, mes_Morders.moentry_sys_stime, icitemlist, sentrys, childidList);
                                        mes_Morders.mat_start_date = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(1).Date;
                                        mes_Morders.mat_end_date = mes_Morders.mat_start_date.GetValueOrDefault().AddDays(make);
                                        if (item.kitting_time < mes_Morders.mat_end_date)
                                        {
                                            item.kitting_time = mes_Morders.mat_end_date;
                                        }
                                        if (IsStraight)
                                        {
                                            //正排
                                            mes_Morders.moentry_sys_stime = item.kitting_time.GetValueOrDefault().AddDays(1).Date;//数据齐套完成后隔天开始生产；
                                            mes_Morders.moentry_sys_etime = mes_Morders.moentry_sys_stime.GetValueOrDefault().AddDays(make);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else if (item.erp_cls == 3 || item.erp_cls == 2)
                {

                    var supplist = supplierList.Where(s => s.icitem_id == item.item_id && s.quota_rate.GetValueOrDefault() > 0).ToList();
                    if (!supplist.Any())
                    {
                        item.stock_state = 99;
                        item.kitting_state = 5;
                        item.kitting_time = plan_date.GetValueOrDefault().AddDays(-1);
                        return;
                    }
                    var maxLeadTime = supplist.Max(x => x.lead_time.GetValueOrDefault());

                    var wwPlan_data = plan_date.GetValueOrDefault().AddDays(-(int)maxLeadTime);
                    decimal wwCount = 0;
                    foreach (var sup in supplist)
                    {
                        decimal suplack_qty = Math.Ceiling(item.lack_qty * sup.quota_rate.GetValueOrDefault() / 100);
                        //先找在途
                        decimal occqty = CalcInTransit(sentrys, item, bangid, plan_date.GetValueOrDefault(), suplack_qty, sup.supplier_id.GetValueOrDefault());
                        decimal lack_qty = suplack_qty - occqty;
                        if (lack_qty > 0)
                        {
                            if (param.checkflag || param.checkPlan)
                            {
                                wwCount += lack_qty;//记录缺料数量
                                if (item.erp_cls == 3)
                                {
                                    //采购申请
                                    PackageSRMPR(item, bangid, sentrys, plan_date, lack_qty, sup.supplier_id.GetValueOrDefault());
                                }
                                else
                                {
                                    //1.先生成委外工单。
                                    var mesorder = CreateMesOOder(item, lack_qty, param.company_id, param.factoryId, bangid, leadTimeList, supplierList, plan_date.GetValueOrDefault());
                                    mesorder.ooentry_etime = plan_date.GetValueOrDefault().AddDays(-1);
                                    var srmprDto = PackageSRMPR(item, bangid, sentrys, plan_date, lack_qty, sup.supplier_id.GetValueOrDefault());
                                    mesorder.ooentry_stime = mesorder.ooentry_etime.GetValueOrDefault().AddDays(-(srmprDto.totalLeadTime.GetValueOrDefault() - 1));
                                }
                            }
                        }
                    }
                    if (item.erp_cls == 2 && wwCount > 0)
                    {
                        //先计算末级数据的齐套时间。
                        if (cilList.Count > 0)//按业务要求，委外件打开向下展开子料
                        {
                            CalcIcitem(cilList, returnlist, bangid, sklist, wwPlan_data, icitemlist, sentrys, childidList);
                            item.kitting_time = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays((int)maxLeadTime);//加上物料的采购提前期
                        }
                        //item.lack_qty = wwCount;
                        item.subcontracting_qty = wwCount;
                        item.subcontracting_list = new List<ooder>();
                    }
                    //else if (item.erp_cls == 3 && wwCount > 0)
                    //{
                    //    item.lack_qty = wwCount;
                    //}
                }
                /*else if (item.erp_cls == 2)
                {

                    if (param.checkflag || param.checkPlan)
                    {
                        //先找在途
                        decimal occqty = CalcInTransit(sentrys, item, bangid, plan_date.GetValueOrDefault());
                        decimal lack_qty = item.lack_qty - occqty;
                        if (lack_qty > 0)
                        {
                            //1.先生成委外工单。
                            var mesorder = CreateMesOOder(item, lack_qty, param.company_id, param.factoryId, bangid, leadTimeList, supplierList, plan_date.GetValueOrDefault());
                            mesorder.ooentry_etime = plan_date.GetValueOrDefault().AddDays(-1);
                            var srmprDto = PackageSRMPR(item, bangid, sentrys, plan_date, lack_qty);
                            mesorder.ooentry_stime = mesorder.ooentry_etime.GetValueOrDefault().AddDays(-(srmprDto.totalLeadTime.GetValueOrDefault() - 1));
                            //先计算末级数据的齐套时间。
                            if (cilList.Count > 0)
                            {
                                CalcIcitem(cilList, returnlist, bangid, sklist, mesorder.ooentry_stime, icitemlist, sentrys, childidList);
                                var itemTime = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());//加上物料的采购提前期
                                if (LongPeriod)
                                {
                                    item.kitting_time = itemTime;
                                }
                                else if(itemTime > item.kitting_time)
                                {
                                    item.kitting_time = itemTime;
                                }
                                if (IsStraight)
                                {
                                    mesorder.ooentry_stime = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(1);
                                    mesorder.ooentry_etime = mesorder.ooentry_stime.GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());
                                }
                            }
                            item.subcontracting_qty = lack_qty;
                            item.subcontracting_list = new List<ooder>();
                            ooder oo = new ooder();
                            oo.Id = mesorder.Id;
                            oo.morder_production_number = mesorder.morder_production_number;
                            oo.production_unit = mesorder.production_unit;
                            oo.production_unit_code = mesorder.production_unit_code;
                            oo.ooentry_prdname = mesorder.ooentry_prdname;
                            oo.ooentry_stime = mesorder.ooentry_stime;
                            oo.ooentry_etime = item.kitting_time;
                            oo.oorder_date = mesorder.oorder_date;
                            oo.oorder_no = mesorder.oorder_no;
                            item.subcontracting_list.Add(oo);
                            orderList.Add(mesorder);
                            
                        }
                    }
                }*/
                else
                {
                    item.kitting_time = DateTime.Now;
                    //先计算末级数据的齐套时间。
                    if (cilList.Count > 0)
                    {
                        CalcIcitem(cilList, returnlist, bangid, sklist, plan_date, icitemlist, sentrys, childidList);
                        item.kitting_time = cilList.Max(s => s.kitting_time);
                        if (item.erp_cls == 4)
                        {
                            if (!cilList.Where(x => x.is_use == true && x.stock_state != 1).Any())
                            {
                                item.stock_state = 1;
                                item.kitting_state = 1;
                            }
                        }
                    }
                }
            }
            else
            {
                //如果父级缺料，则本级等于父级缺料*本级使用数量
                if (parent != null)
                {
                    item.use_qty = item.self_lack_qty;
                    item.kitting_time = DateTime.Now;
                    itemStockoccupyDto.quantity = item.use_qty;
                }
                sklist.Add(itemStockoccupyDto);
                newStockOccList.Add(itemStockoccupyDto);
            }
        }

        /// <summary>
        /// 根据替代策略计算
        /// </summary>
        /// <param name="item"></param>
        /// <param name="returnlist"></param>
        /// <param name="bangid"></param>
        /// <param name="sklist"></param>
        /// <param name="input"></param>
        /// <param name="plan_date"></param>
        public void CalcStrategy(BomChildExamineDto item, List<BomChildExamineDto> returnlist, long bangid, List<mo_ic_item_stockoccupy> sklist, DateTime
            ? plan_date, List<mo_ic_item> icitemlist, crm_seorderentry sentrys, List<long> childidList)
        {
            //提取群组关系
            var sublist = returnlist.Where(s => s.parent_id == item.parent_id && s.num == item.num && s.level == item.level).OrderBy(c => c.substitute_all_num).ToList();
            List<BomChildExamineDto> select = new List<BomChildExamineDto>();
            var parent = returnlist.Find(s => s.fid == item.parent_id);
            switch (item.substitute_strategy)
            {
                case 0://整批
                    WholeBatchCheck(sublist, returnlist, sklist, select, bangid);
                    //如果都需要采购的情况下，则默认使用优先级最高的
                    WholeBatch(item, sublist, returnlist, sklist, select, bangid, parent, plan_date, icitemlist, sentrys, childidList);
                    break;
                case 1://混用
                    MixedUse(item, sublist, returnlist, sklist, bangid, parent, plan_date, icitemlist, sentrys, childidList);
                    break;
                case 2://整批加混用
                    WholeBatchCheck(sublist, returnlist, sklist, select, bangid);
                    if (select.Count == 0)
                    {
                        //走混用
                        MixedUse(item, sublist, returnlist, sklist, bangid, parent, plan_date, icitemlist, sentrys, childidList);
                    }
                    else
                    {
                        //走整批
                        WholeBatch(item, sublist, returnlist, sklist, select, bangid, parent, plan_date, icitemlist, sentrys, childidList);
                    }
                    break;
            }
        }
        /// <summary>
        /// 整批计算
        /// </summary>
        /// <param name="sublist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="select"></param>
        public void WholeBatchCheck(List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<mo_ic_item_stockoccupy> sklist, List<BomChildExamineDto> select, long bangid)
        {

            List<int> orderNum = sublist.Select(s => s.substitute_all_num.GetValueOrDefault()).ToList();
            orderNum.Sort();
            foreach (var order in orderNum)
            {
                var list = sublist.Where(s => s.substitute_all_num == order).ToList();
                if (list.Any())
                {
                    foreach (var s in list)
                    {
                        RecalculationStock(s, returnlist, newStockOccList, bangid);
                    }
                    //可制计算:需要对list进行可制计算，按主料来算辅料
                    if (list.Where(s => s.stock_state != 1).Count() == 0)
                    {
                        //只满足充足或可制
                        //无缺料情况
                        list.ForEach(s => { s.is_use = true; });
                        select.AddRange(list);
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// 整批占用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sublist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="select"></param>
        /// <param name="bangid"></param>
        /// <param name="parent"></param>
        /// <param name="plan_date"></param>
        public void WholeBatch(BomChildExamineDto item, List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<mo_ic_item_stockoccupy> sklist, List<BomChildExamineDto> select, long bangid, BomChildExamineDto parent, DateTime
            ? plan_date, List<mo_ic_item> icitemlist, crm_seorderentry sentrys, List<long> childidList)
        {
            if (select.Count == 0)
            {
                //如果为空，则默认使用优先级为0的集合作为替代关系
                if (item.substitute_mode == 0)
                {
                    //替代
                    select = sublist.Where(s => s.type == 0).ToList();
                }
                else
                {
                    int orderNum = sublist.Where(s => s.type == 1).Select(s => s.substitute_all_num.GetValueOrDefault()).ToList().Min();
                    //取代
                    select = sublist.Where(s => s.substitute_all_num == orderNum).ToList();
                }
                select.ForEach(s => { s.is_use = true; });
            }
            //占用库存
            foreach (var slt in select)
            {
                slt.self_lack_qty = (parent.lack_qty - parent.mo_qty - parent.purchase_occupy_qty) * slt.qty;
                mo_ic_item_stockoccupy itemStockoccupyDto = new mo_ic_item_stockoccupy();
                itemStockoccupyDto.bang_id = bangid;
                itemStockoccupyDto.icitem_id = slt.item_id;
                itemStockoccupyDto.icitem_number = slt.item_number;
                itemStockoccupyDto.item_no = slt.num;
                itemStockoccupyDto.occupy_time = DateTime.Now;
                if (sentrys != null)
                {
                    itemStockoccupyDto.orderentry_id = sentrys.Id;
                    itemStockoccupyDto.order_id = sentrys.seorder_id;
                }
                if (mes_morder != null)
                {
                    itemStockoccupyDto.morder_id = mes_morder.Id;
                    itemStockoccupyDto.morder_mo = mes_morder.morder_no;
                }
                slt.is_use = true;
                StartProcessing(slt, icitemlist, returnlist, plan_date, sentrys, sklist, itemStockoccupyDto, bangid, childidList);
            }

        }

        /// <summary>
        /// 混用占用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sublist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="bangid"></param>
        /// <param name="parent"></param>
        /// <param name="plan_date"></param>
        public void MixedUse(BomChildExamineDto item, List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<mo_ic_item_stockoccupy> sklist, long bangid, BomChildExamineDto parent, DateTime
            ? plan_date, List<mo_ic_item> icitemlist, crm_seorderentry sentrys, List<long> childidList)
        {

            decimal parent_lack = 0;
            if (parent != null)
            {
                parent_lack = parent.lack_qty - parent.mo_qty - parent.purchase_occupy_qty;
            }
            decimal subCount = item.needCount;
            List<int> orderNum = sublist.Select(s => s.substitute_all_num.GetValueOrDefault()).ToList();
            orderNum.Sort();
            foreach (var idx in orderNum)
            {
                if (parent_lack <= 0)
                {
                    break;
                }
                var list = sublist.Where(s => s.substitute_all_num == idx).ToList();
                if (list.Any())
                {
                    foreach (var s in list)
                    {
                        RecalculationStock(s, returnlist, newStockOccList, bangid);
                    }
                    decimal minMake = 99999999;
                    foreach (var hy in list)
                    {
                        //混用先使用掉当前要用的数量
                        //得到库存最小数量，去占用，然后剩余的丢第二个循环里去占用。
                        //获取物料详情
                        /*var ic_item = icitemlist.Find(s => s.Id == hy.item_id);
                        var mooccupylist = _morderAppService.CheckMorder(hy.bom_number, hy.lack_qty, plan_date.GetValueOrDefault(), sentrys, ic_item, false).Result;
                        decimal moo_qty = mooccupylist.Sum(s => s.moo_qty.GetValueOrDefault());
                        decimal make = (hy.sqty + moo_qty) / hy.qty;
                        if (Math.Floor(hy.qty) == hy.qty)
                        {
                            //如果物料的使用数量是小数，则按小数计算。
                            make = Math.Floor(make);
                        }
                        if (minMake > make)
                        {
                            minMake = make;
                        }*/
                        //先去掉上面的在制
                        decimal make = hy.sqty / hy.qty;
                        if (Math.Floor(hy.qty) == hy.qty)
                        {
                            //如果物料的使用数量是小数，则按小数计算。
                            make = Math.Floor(make);
                        }
                        if (minMake > make)
                        {
                            minMake = make;
                        }

                    }
                    decimal use_p_num = 0;
                    if (parent_lack > minMake) //20>10
                    {
                        use_p_num = minMake;
                        parent_lack -= use_p_num;
                    }
                    else
                    {
                        use_p_num = parent_lack;
                        parent_lack = 0;
                    }
                    //根据混用逻辑，去占用物料
                    foreach (var zy in list)
                    {
                        zy.is_use = true;
                        zy.kitting_time = DateTime.Now;
                        if (parent_lack <= 0)
                        {
                            zy.stock_state = 1;
                        }
                        mo_ic_item_stockoccupy itemStockoccupyDto = new mo_ic_item_stockoccupy();
                        if (sentrys != null)
                        {
                            itemStockoccupyDto.orderentry_id = sentrys.Id;
                            itemStockoccupyDto.order_id = sentrys.seorder_id;
                        }
                        if (mes_morder != null)
                        {
                            itemStockoccupyDto.morder_id = mes_morder.Id;
                            itemStockoccupyDto.morder_mo = mes_morder.morder_no;
                        }
                        itemStockoccupyDto.occupy_time = DateTime.Now;
                        itemStockoccupyDto.bang_id = bangid;
                        itemStockoccupyDto.icitem_id = zy.item_id;
                        itemStockoccupyDto.icitem_number = zy.item_number;
                        /*decimal moo_qty = use_p_num * zy.qty - zy.sqty;
                        if (moo_qty > 0)
                        {
                            var ic_item = icitemlist.Find(s => s.Id == zy.item_id);
                            var mooccupylist = _morderAppService.CheckMorder(zy.bom_number, moo_qty, plan_date.GetValueOrDefault(), sentrys, ic_item).Result;
                            itemStockoccupyDto.quantity = zy.sqty;
                            zy.use_qty = zy.sqty;
                            zy.mo_qty = moo_qty;
                            zy.mo_occupy_list = new List<mo_occupy>();
                            mooccupylist.ForEach(s =>
                            {
                                mo_occupy mooc = new mo_occupy();
                                mooc.moo_mo = s.moo_mo;
                                mooc.moo_stime = s.moo_ctime;
                                mooc.moo_etime = s.moo_etime;
                                mooc.moo_qty = s.moo_qty;
                                zy.mo_occupy_list.Add(mooc);
                            });
                        }
                        else
                        {
                            zy.use_qty = use_p_num * zy.qty;
                            itemStockoccupyDto.quantity = zy.use_qty;
                        }*/
                        //先去掉上面的在制逻辑
                        zy.use_qty = use_p_num * zy.qty;
                        zy.needCount = zy.use_qty;
                        subCount -= zy.needCount;
                        itemStockoccupyDto.quantity = zy.use_qty;
                        itemStockoccupyDto.item_no = zy.num;
                        sklist.Add(itemStockoccupyDto);
                        newStockOccList.Add(itemStockoccupyDto);
                    }
                }
            }
            if (parent_lack > 0)
            {
                var select = new List<BomChildExamineDto>();
                if (item.substitute_mode == 0)
                {
                    //替代
                    select = sublist.Where(s => s.type == 0).ToList();
                }
                else
                {
                    int minNum = sublist.Where(s => s.type == 1).Select(s => s.substitute_all_num.GetValueOrDefault()).ToList().Min();
                    //取代
                    select = sublist.Where(s => s.substitute_all_num == minNum).ToList();
                }
                //对select执行补充（根据属性采购、外购、自制等）
                foreach (var sct in select)
                {
                    sct.needCount = subCount > 0 ? subCount : 0;
                    decimal sqty = sct.sqty - sct.use_qty;//这里得出前面混用使用后的库存。
                    decimal lack_Count = sct.self_lack_qty;//混用后还缺的部分。
                    mo_ic_item_stockoccupy itemStockoccupyDto = new mo_ic_item_stockoccupy();
                    if (sentrys != null)
                    {
                        itemStockoccupyDto.orderentry_id = sentrys.Id;
                        itemStockoccupyDto.order_id = sentrys.seorder_id;
                    }
                    if (mes_morder != null)
                    {
                        itemStockoccupyDto.morder_id = mes_morder.Id;
                        itemStockoccupyDto.morder_mo = mes_morder.morder_no;
                    }
                    itemStockoccupyDto.occupy_time = DateTime.Now;
                    itemStockoccupyDto.bang_id = bangid;
                    itemStockoccupyDto.icitem_id = sct.item_id;
                    itemStockoccupyDto.icitem_number = sct.item_number;
                    itemStockoccupyDto.item_no = sct.num;
                    decimal lack_num = sqty - lack_Count;//库存还够缺的部分
                    if (lack_num >= 0)
                    {
                        //剩余得库存还够还缺的部分
                        itemStockoccupyDto.quantity = lack_Count;
                        sct.use_qty += lack_Count;
                        sklist.Add(itemStockoccupyDto);
                        newStockOccList.Add(itemStockoccupyDto);
                    }
                    else
                    {
                        var cilList = returnlist.Where(s => s.parent_id == sct.fid && s.type == sct.type).OrderBy(k => k.num_order).ToList();

                        itemStockoccupyDto.quantity = sqty;
                        sklist.Add(itemStockoccupyDto);
                        newStockOccList.Add(itemStockoccupyDto);
                        sct.lack_qty = lack_num * -1;
                        sct.kitting_time = DateTime.Now;
                        sct.use_qty += sqty;

                        DateTime dateTime = plan_date.GetValueOrDefault();
                        //增加前处理时间
                        if (item.clean_leadtime.GetValueOrDefault() != 0)
                        {
                            dateTime = dateTime.AddDays(-(int)Math.Ceiling(sct.clean_leadtime.GetValueOrDefault()));
                        }
                        if (sct.erp_cls == 1)
                        {
                            var ic_item = icitemlist.Find(s => s.mysql_id == sct.item_id);
                            List<mo_mes_mooccupy> mooccupylist = new List<mo_mes_mooccupy>();
                            if ((param.checkflag || param.checkPlan) && !LongPeriod)
                            {
                                mooccupylist = _morderAppService.CheckMorder(sct.item_number, sct.lack_qty, dateTime, sentrys, ic_item, bangid, mes_morder);
                            }
                            decimal moo_qty = mooccupylist.Sum(s => s.moo_qty.GetValueOrDefault());
                            sct.mo_qty = moo_qty;
                            sct.kitting_time = DateTime.Now;
                            if (mooccupylist.Any())
                            {
                                mooccupyAllList.AddRange(mooccupylist);
                                mooccupyAllInsertList.AddRange(mooccupylist);
                                sct.kitting_time = mooccupylist[0].moo_etime;
                                //在制占用明细
                                sct.mo_occupy_list = new List<mo_occupy>();
                                mooccupylist.ForEach(s =>
                                {
                                    mo_occupy mooc = new mo_occupy();
                                    mooc.id = s.Id;
                                    mooc.moo_mo = s.moo_mo;
                                    mooc.moo_stime = s.moo_ctime;
                                    mooc.moo_etime = s.moo_etime;
                                    mooc.moo_qty = s.moo_qty;
                                    sct.mo_occupy_list.Add(mooc);
                                });
                            }
                            if (moo_qty == sct.lack_qty)
                            {
                                //在制完全足够
                                sct.lack_qty = 0;
                                sct.stock_state = 1;
                            }
                            else if (!LongPeriod)
                            {
                                //sct.lack_qty -= moo_qty;
                                sct.make_qty = item.lack_qty - sct.mo_qty;
                                sct.stock_state = 0;
                                sct.kitting_time = dateTime;
                            }
                            else
                            {
                                //sct.lack_qty -= moo_qty;
                                List<string> tsWork = new List<string> { "试制工单", "TCN工单", "返工工单" };
                                //如果是特殊工单，只判断自制件的库存和在制，而不生成自制
                                if (!tsWork.Contains(mes_morder.morder_type))
                                {
                                    //TODO：需要按标准UPH来计算生产时长
                                    //生成主工单
                                    sct.make_qty = sct.lack_qty - sct.mo_qty;
                                    string order_mo = "";
                                    if (GenerateMoList.Any())
                                    {
                                        order_mo = GenerateMoList[0];
                                        GenerateMoList.Remove(order_mo);
                                    }
                                    GenerateMorderDto generateMorderDto = new GenerateMorderDto()
                                    {
                                        seorderentry = sentrys,
                                        seorder = seorder,
                                        ic_Item = ic_item,
                                        BomNumber = sct.bom_number,
                                        version = sct.version,
                                        number = sct.item_number,
                                        Quantity = sct.make_qty,
                                        morder_type = morder_type,
                                        work_order_type = MorderEnum.CgMorder,
                                        morder_state = MorderEnum.Initial_state,
                                        ParentId = mes_morder.Id,
                                        bang_id = bangid,
                                        morder_no = order_mo
                                    };
                                    Mes_MorderDto mes_MorderDto = _morderAppService.GenerateMorder(generateMorderDto);
                                    ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                                    {
                                        ItemNum = sct.item_number,
                                        PlanStart = dateTime,
                                        QtyOrd = sct.make_qty,
                                        Domain = param.factoryId.ToString()
                                    };
                                    int make = _productExamineAppService.ProductTime(prodExamine);

                                    if (mes_MorderDto != null)
                                    {
                                        //主工单最后计算满足日期
                                        var mes_Morders = mes_MorderDto.mes_Morders.FirstOrDefault();
                                        if (mes_Morders != null)
                                        {
                                            var generateMooccupy = _morderAppService.GetMooccupies(sentrys, ic_item, mes_Morders, sct.make_qty, bangid);
                                            mooccupyAllList.Add(generateMooccupy);
                                            mooccupyAllInsertList.Add(generateMooccupy);

                                            //子工单生成的检查明细，还是挂接到主工单上。
                                            //mes_morder = ObjectMapper.Map<mo_mes_morder, mes_morder>(mes_Morders);
                                            mes_Morders.moentry_sys_etime = dateTime.AddDays(-1 - ic_item.PurLT);
                                            mes_Morders.moentry_sys_stime = mes_Morders.moentry_sys_etime.GetValueOrDefault().AddDays(-(make - 1));
                                            sct.make_list = new List<moorder>();
                                            mes_MorderDto.mes_Morders.ForEach(me =>
                                            {
                                                moorder mo = new moorder();
                                                mo.Id = me.Id;
                                                mo.moentry_stime = me.moentry_stime;
                                                mo.moentry_etime = me.moentry_etime;
                                                mo.moentry_wrkcname = me.moentry_wrkcname;
                                                mo.moentry_sys_stime = me.moentry_sys_stime;
                                                mo.moentry_sys_etime = me.moentry_sys_etime;
                                                mo.moentry_prdname = me.moentry_prdname;
                                                mo.morder_need_time = me.morder_need_time;
                                                mo.morder_no = me.morder_no;
                                                mo.morder_production_number = me.morder_production_number;
                                                mo.need_number = me.need_number;
                                                mo.reality_end_time = me.reality_end_time;
                                                mo.reality_start_time = me.reality_start_time;
                                                sct.make_list.Add(mo);
                                            });
                                            //批量保存 后期考虑子工单
                                            mordersList.AddRange(mes_MorderDto.mes_Morders);
                                            mordersInsertList.AddRange(mes_MorderDto.mes_Morders);
                                            moentriesList.AddRange(mes_MorderDto.mes_Moentries);
                                            moentriesInsertList.AddRange(mes_MorderDto.mes_Moentries);

                                            mes_Morders.mat_start_date = sct.kitting_time.GetValueOrDefault().AddDays(1).Date;//数据齐套完成后隔天开始生产；
                                                                                                                              //先计算末级数据的齐套时间。
                                            if (cilList.Count > 0)
                                            {
                                                CalcIcitem(cilList, returnlist, bangid, sklist, mes_Morders.moentry_sys_stime, icitemlist, sentrys, childidList);
                                                mes_Morders.mat_start_date = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(1).Date;
                                                mes_Morders.mat_end_date = mes_Morders.mat_start_date.GetValueOrDefault().AddDays(make);
                                                if (sct.kitting_time < mes_Morders.mat_end_date)
                                                {
                                                    sct.kitting_time = mes_Morders.mat_end_date;
                                                }
                                                if (IsStraight)
                                                {
                                                    //正排
                                                    mes_Morders.moentry_sys_stime = sct.kitting_time.GetValueOrDefault().AddDays(1).Date;//数据齐套完成后隔天开始生产；
                                                    mes_Morders.moentry_sys_etime = mes_Morders.moentry_sys_stime.GetValueOrDefault().AddDays(make);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else if (sct.erp_cls == 3)
                        {
                            if (param.checkflag || param.checkPlan)
                            {
                                var supplist = supplierList.Where(s => s.icitem_id == sct.item_id && s.quota_rate.GetValueOrDefault() > 0).ToList();
                                if (!supplist.Any())
                                {
                                    sct.stock_state = 99;
                                    sct.kitting_time = plan_date.GetValueOrDefault().AddDays(-1);
                                    return;
                                }
                                var maxLeadTime = supplist.Max(x => x.lead_time.GetValueOrDefault());
                                var wwPlan_data = plan_date.GetValueOrDefault().AddDays(-(int)maxLeadTime);
                                decimal wwCount = 0;

                                foreach (var sup in supplist)
                                {
                                    decimal suplack_qty = Math.Ceiling(sct.lack_qty * sup.quota_rate.GetValueOrDefault() / 100);
                                    //先找在途
                                    decimal occqty = CalcInTransit(sentrys, sct, bangid, plan_date.GetValueOrDefault(), suplack_qty, sup.supplier_id.GetValueOrDefault());
                                    decimal lack_qty = suplack_qty - occqty;
                                    if (lack_qty > 0)
                                    {
                                        wwCount += lack_qty;//记录缺料数量
                                        if (sct.erp_cls == 3)
                                        {
                                            //采购申请
                                            PackageSRMPR(sct, bangid, sentrys, plan_date, lack_qty, sup.supplier_id.GetValueOrDefault());
                                        }
                                        else
                                        {
                                            //1.先生成委外工单。
                                            var mesorder = CreateMesOOder(sct, lack_qty, param.company_id, param.factoryId, bangid, leadTimeList, supplierList, plan_date.GetValueOrDefault());
                                            mesorder.ooentry_etime = plan_date.GetValueOrDefault().AddDays(-1);
                                            var srmprDto = PackageSRMPR(sct, bangid, sentrys, plan_date, lack_qty, sup.supplier_id);
                                            mesorder.ooentry_stime = mesorder.ooentry_etime.GetValueOrDefault().AddDays(-(srmprDto.totalLeadTime.GetValueOrDefault() - 1));
                                        }
                                    }
                                }
                                if (sct.erp_cls == 2 && wwCount > 0)
                                {
                                    //先计算末级数据的齐套时间。
                                    if (cilList.Count > 0)//按业务要求，委外件向下展开子料
                                    {
                                        CalcIcitem(cilList, returnlist, bangid, sklist, wwPlan_data, icitemlist, sentrys, childidList);
                                        sct.kitting_time = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays((int)maxLeadTime);//加上物料的采购提前期
                                    }
                                    sct.subcontracting_qty = wwCount;
                                    sct.subcontracting_list = new List<ooder>();
                                }
                            }
                        }
                        /*else if (sct.erp_cls == 2)
                        {
                            if (param.checkflag || param.checkPlan)
                            {
                                //先找在途
                                decimal occqty = CalcInTransit(sentrys, sct, bangid, plan_date.GetValueOrDefault());
                                decimal lack_qty = sct.lack_qty - occqty;
                                if (lack_qty > 0)
                                {
                                    //1.先生成委外工单。
                                    var mesorder = CreateMesOOder(sct, lack_qty, param.company_id, param.factoryId, bangid, leadTimeList, supplierList, plan_date.GetValueOrDefault());
                                    mesorder.ooentry_etime = plan_date.GetValueOrDefault().AddDays(-1);
                                    var srmprDto = PackageSRMPR(sct, bangid, sentrys, plan_date, lack_qty);
                                    mesorder.ooentry_stime = mesorder.ooentry_etime.GetValueOrDefault().AddDays(-(srmprDto.totalLeadTime.GetValueOrDefault() - 1));

                                    //先计算末级数据的齐套时间。
                                    if (cilList.Count > 0)
                                    {
                                        CalcIcitem(cilList, returnlist, bangid, sklist, mesorder.ooentry_stime, icitemlist, sentrys, childidList);
                                        //sct.kitting_time = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());//加上物料的采购提前期
                                        var itemTime = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());//加上物料的采购提前期
                                        if (LongPeriod)
                                        {
                                            sct.kitting_time = itemTime;
                                        }
                                        else if (itemTime > sct.kitting_time)
                                        {
                                            sct.kitting_time = itemTime;
                                        }
                                        if (IsStraight)
                                        {
                                            mesorder.ooentry_stime = cilList.Max(s => s.kitting_time).GetValueOrDefault().AddDays(1);
                                            mesorder.ooentry_etime = mesorder.ooentry_stime.GetValueOrDefault().AddDays(srmprDto.totalLeadTime.GetValueOrDefault());
                                        }
                                    }
                                    sct.subcontracting_qty = lack_qty;
                                    sct.subcontracting_list = new List<ooder>();
                                    ooder oo = new ooder();
                                    oo.Id = mesorder.Id;
                                    oo.morder_production_number = mesorder.morder_production_number;
                                    oo.production_unit = mesorder.production_unit;
                                    oo.production_unit_code = mesorder.production_unit_code;
                                    oo.ooentry_prdname = mesorder.ooentry_prdname;
                                    oo.ooentry_stime = mesorder.ooentry_stime;
                                    oo.ooentry_etime = mesorder.ooentry_etime;
                                    oo.oorder_date = mesorder.oorder_date;
                                    oo.oorder_no = mesorder.oorder_no;
                                    item.subcontracting_list.Add(oo);
                                    orderList.Add(mesorder);
                                }
                            }
                        }*/
                        else
                        {
                            if (cilList.Count > 0)
                            {
                                CalcIcitem(cilList, returnlist, bangid, sklist, plan_date, icitemlist, sentrys, childidList);
                                sct.kitting_time = cilList.Max(s => s.kitting_time);
                                if (sct.erp_cls == 4)
                                {
                                    if (!cilList.Where(x => x.is_use == true && x.stock_state != 1).Any())
                                    {
                                        sct.stock_state = 1;
                                    }
                                }
                            }
                        }
                    }

                }
            }
        }



        /// <summary>
        /// 根据占用情况重新计算占用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        public void RecalculationStock(BomChildExamineDto item, List<BomChildExamineDto> returnlist, List<mo_ic_item_stockoccupy> sklist, long bangid)
        {
            //再计算一边占用情况，这里根据父级产品额缺料量*当前子料的使用数量-子料库存量。得出当前子物料的缺料数量
            var parent = returnlist.Find(s => s.fid == item.parent_id);
            decimal stockQty = sklist.Where(s => s.icitem_id == item.item_id && s.bang_id == bangid).Sum(p => p.quantity);
            item.sqty -= stockQty;
            item.sqty = item.sqty < 0 ? 0 : item.sqty;
            item.lack_qty = (parent.lack_qty - parent.mo_qty - parent.purchase_occupy_qty) * item.qty - item.sqty;
            item.lack_qty = item.lack_qty > 0 ? item.lack_qty : 0;
            item.self_lack_qty = item.lack_qty;
            item.stock_state = item.lack_qty > 0 ? 0 : 1;
        }


        /// <summary>
        /// 生成采购申请单,颗粒度是一个物料一个单，没必要弄列表
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="factoryid"></param>
        /// <param name="orderType">2委外采购申请单，3采购申请单</param>
        private SRMPRDto CreateSRMPR(BomChildExamineDto returnlist, decimal lack_qty, long? companyId, long factoryid, long bangId, int orderType, List<ICItemLeadTimeDto> iCItemLeadTimes, List<mo_srm_purchase> supplierList, List<mo_ic_item> planList, crm_seorderentry sentrys, DateTime? plan_date, long? supplier_id)
        {
            SRMPRDto sRMPR = new SRMPRDto();
            //mo_srm_purchase supplier = null;
            var plan = planList.Find(x => x.mysql_id == returnlist.item_id);
            var supplist = supplierList.Where(s => s.icitem_id == returnlist.item_id && s.quota_rate.GetValueOrDefault() > 0).ToList();
            if (supplier_id != null)
            {
                supplist = supplist.Where(s => s.supplier_id == supplier_id).ToList();
            }
            if (!supplist.Any() || plan == null)
            {
                returnlist.stock_state = 99;
                sRMPR.lastStartTmie = DateTime.Now.AddDays(7);//默认采购提前期
                sRMPR.totalLeadTime = 7;
                return sRMPR;
            }
            sRMPR.srm_Pr_Main = new List<mo_srm_pr_main>();
            foreach (var supplier in supplist)
            {
                mo_srm_pr_main srm_Pr = new mo_srm_pr_main();
                srm_Pr.GenerateNewId(help.NextId());
                srm_Pr.mysql_id = help.NextId();
                if (mes_morder != null)
                {
                    srm_Pr.pr_mono = mes_morder.morder_no;//关联工单号
                    srm_Pr.entity_id = 1;//工单行号
                }
                srm_Pr.pr_order_type = returnlist.erp_cls == 2 ? "L" : "";//单据类型
                srm_Pr.supplier_type = supplier.supplier_type;
                srm_Pr.IsRequireGoods = supplier.IsRequireGoods;
                if (supplier.supplier_type == "VMI")
                {
                    srm_Pr.IsRequireGoods = 1;
                    srm_Pr.pr_order_type = "K";
                }
                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;//采购员工号（采购信息表）

                if (supplier_id != null)
                {
                    srm_Pr.pr_rqty = Math.Ceiling(lack_qty);//需求数量
                }
                else
                {
                    srm_Pr.pr_rqty = Math.Ceiling(lack_qty * supplier.quota_rate.GetValueOrDefault() / 100);//需求数量
                }
                srm_Pr.pr_aqty = srm_Pr.pr_rqty;//申请数量
                srm_Pr.pr_sqty = srm_Pr.pr_rqty;//建议数量
                srm_Pr.icitem_id = returnlist.item_id;//物料id
                srm_Pr.icitem_name = returnlist.item_name;//物料名称
                srm_Pr.num = returnlist.num;
                if (ScheduleAgreement)
                {
                    supplier.lead_time = 7;//启用计划协议时，默认为7天。
                }
                if (plan_date != null)
                {
                    //-1为提前一天准备
                    srm_Pr.pr_sarrive_date = plan_date.GetValueOrDefault().AddDays(-1 - (int)(Math.Ceiling(plan.clean_leadtime.GetValueOrDefault() + plan.self_inspection_date.GetValueOrDefault())));
                    /*if (LongPeriod)
                    {
                        //提前一个月
                        srm_Pr.pr_sarrive_date = srm_Pr.pr_sarrive_date.GetValueOrDefault().AddMonths(-1);
                    }*/
                    srm_Pr.pr_ssend_date = srm_Pr.pr_sarrive_date.Value.AddDays(-(int)Math.Ceiling(supplier.lead_time.GetValueOrDefault()));//系统建议下单日期
                    if (srm_Pr.pr_ssend_date < DateTime.Now.Date.AddDays(1) && !LongPeriod)
                    {
                        //如果建议下单日期为今天或者过去，则代表物料需求供应时间不够，则需要标记此物料时间不足。
                        var timeSp = DateTime.Now - srm_Pr.pr_ssend_date.Value;
                        returnlist.pre_time = timeSp.Days + 1;
                        srm_Pr.pr_ssend_date = srm_Pr.pr_ssend_date.Value.AddDays(returnlist.pre_time.GetValueOrDefault());
                        //修改逻辑为按实际计算结果取交货日期
                        //srm_Pr.pr_sarrive_date = srm_Pr.pr_sarrive_date.Value.AddDays(returnlist.pre_time.GetValueOrDefault());
                    }
                }
                else
                {
                    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 = srm_Pr.pr_rqty * supplier.order_price;//订单价格（含税）
                srm_Pr.pr_price = supplier.netpurchase_price;//采购净价（不含税）
                srm_Pr.pr_rate = supplier.taxrate;//税率
                srm_Pr.pr_unit = returnlist.unit;//单位
                srm_Pr.state = 1;//状态
                srm_Pr.old_apply_aqty = 0;//已申请数量
                srm_Pr.pr_type = orderType;//申请类型
                srm_Pr.currencytype = supplier.currency_type == null ? 1 : supplier.currency_type.Value;//币种
                srm_Pr.secInv_ratio = plan.secinv_ratio;//安全库存触发采购比例
                srm_Pr.tenant_id = companyId.GetValueOrDefault();
                srm_Pr.company_id = companyId;
                srm_Pr.factory_id = factoryid;
                srm_Pr.bang_id = bangId;
                if (sentrys != null)
                {
                    srm_Pr.sentry_id = sentrys.Id;
                }
                srm_Pr.totalLeadTime = supplier.lead_time.GetValueOrDefault();//plan.transportation_leadtime + plan.stock_leadtime + plan.production_leadtime + plan.order_leadtime;
                srm_Pr.create_time = DateTime.Now;
                srm_Pr.create_by_name = "admin";
                srm_Pr.update_time = DateTime.Now;
                srm_Pr.update_by_name = "admin";
                sRMPR.srm_Pr_Main.Add(srm_Pr);
                quarter_srm_pr_mains.Add(srm_Pr);

                //生成mo_srm_po_occupy采购占用表数据。 
                mo_srm_po_occupy srm_Po_Occupy = new mo_srm_po_occupy();
                srm_Po_Occupy.GenerateNewId(help.NextId());
                srm_Po_Occupy.mysql_id = help.NextId();
                srm_Po_Occupy.bang_id = bangId;
                srm_Po_Occupy.polist_id = srm_Pr.mysql_id;
                if (sentrys != null)
                {
                    srm_Po_Occupy.eid = sentrys.Id;
                    srm_Po_Occupy.bill_no = sentrys.seorder_id;
                    srm_Po_Occupy.entry_id = sentrys.entry_seq.GetValueOrDefault();
                    srm_Po_Occupy.org_id = sentrys.org_id;
                }
                if (mes_morder != null)
                {
                    srm_Po_Occupy.morder_id = mes_morder.Id;
                    srm_Po_Occupy.morder_mo = mes_morder.morder_no;
                }
                srm_Po_Occupy.qty = srm_Pr.pr_rqty;
                srm_Po_Occupy.type = MorderEnum.Zyjc_Type;//TODO:类型未知
                srm_Po_Occupy.stime = srm_Pr.pr_ssend_date;
                srm_Po_Occupy.etime = srm_Pr.pr_sarrive_date;
                srm_Po_Occupy.state = 1;
                srm_Po_Occupy.company_id = param.company_id;//取销售子表企业ID
                srm_Po_Occupy.factory_id = param.factoryId;
                srm_Po_OccupiesInsert.Add(srm_Po_Occupy);
            }
            sRMPR.totalLeadTime = (int)Math.Ceiling(sRMPR.srm_Pr_Main.Max(x => x.totalLeadTime.GetValueOrDefault()));

            if (sRMPR.srm_Pr_Main.Any())
            {
                sRMPR.srm_Pr_Main.OrderBy(x => x.totalLeadTime.GetValueOrDefault()).ThenBy(x => x.pr_orderprice.GetValueOrDefault()).First().isbestoptions = true;
            }
            sRMPR.item_no = returnlist.num;
            sRMPR.orderentry_id = returnlist.sentry_id;
            sRMPR.lastStartTmie = sRMPR.srm_Pr_Main.Max(x => x.pr_sarrive_date.GetValueOrDefault());
            return sRMPR;
        }

        /*/// <summary>
        /// 生成采购申请单,颗粒度是一个物料一个单，没必要弄列表
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="factoryid"></param>
        /// <param name="orderType">2委外采购申请单，3采购申请单</param>
        private SRMPRDto CreateSRMPR(BomChildExamineDto returnlist, decimal lack_qty, long? companyId, long factoryid, long bangId, int orderType, List<ICItemLeadTimeDto> iCItemLeadTimes, List<mo_srm_purchase> supplierList, List<mo_ic_item> planList, crm_seorderentry sentrys, DateTime? plan_date)
        {
            SRMPRDto sRMPR = new SRMPRDto();
            mo_srm_purchase supplier = null;
            var plan = planList.Find(x => x.mysql_id == returnlist.item_id);
            var supplist = supplierList.Where(s => s.icitem_id == returnlist.item_id && s.quota_rate.GetValueOrDefault() > 0).ToList();
            decimal day = 0;
            if (!supplist.Any() || plan == null)
            {
                returnlist.stock_state = 99;
                sRMPR.lastStartTmie = DateTime.Now.AddDays(7);//默认采购提前期
                sRMPR.totalLeadTime = 7;
                return sRMPR;
            }
            if (plan_date != null && returnlist.erp_cls == 3)
            {
                //判断当前时间与交期还剩余多少天
                var timesp = plan_date.GetValueOrDefault() - DateTime.Now.Date;
                //交期-生产时长-物料前处理周期
                day = timesp.Days;
                if (day > 0)
                {
                    List<mo_srm_purchase> newsupplist = supplist.Where(s => s.lead_time.GetValueOrDefault() < day).ToList();
                    if (newsupplist.Any())
                    {
                        //TODO:走配额管理
                        List<mo_srm_pr_main> itemPrlist = quarter_srm_pr_mains.Where(s => s.icitem_id == returnlist.item_id).ToList();
                        if (itemPrlist.Any())
                        {
                            decimal qtyCount = itemPrlist.Sum(x => x.pr_aqty).GetValueOrDefault();
                            //按配额比例，计算使用哪个供应商。
                            List<PrPurchaseDto> PrPurchaseDtoList = new List<PrPurchaseDto>();
                            newsupplist.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 * 100, 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 = newsupplist.Find(s => s.supplier_id == dto1.pr_purchaseid);
                        }
                        else
                        {
                            supplier = newsupplist.OrderBy(s => s.quota_priority).FirstOrDefault();//默认取配额优先级
                        }
                    }
                    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();//默认取配额优先级
            }
            if (supplier == null)
            {
                returnlist.stock_state = 99;
                sRMPR.lastStartTmie = DateTime.Now.AddDays(7);//默认采购提前期
                sRMPR.totalLeadTime = 7;
                return sRMPR;
            }

            sRMPR.srm_Pr_Main = new List<mo_srm_pr_main>();
            mo_srm_pr_main srm_Pr = new mo_srm_pr_main();
            srm_Pr.GenerateNewId(help.NextId());
            srm_Pr.mysql_id = help.NextId();
            //srm_Pr.pr_billno = returnlist.erp_cls == 2 ? getOrderNum("WWPR") : getOrderNum("PR");//pr单号
            //_serialNumberAppService.GetBillNo(factoryid.ToString(), "DO", 1, "admin", 1);
            if (mes_morder != null)
            {
                srm_Pr.pr_mono = mes_morder.morder_no;//关联工单号
                srm_Pr.entity_id = 1;//工单行号
            }
            srm_Pr.pr_order_type = returnlist.erp_cls == 2 ? "L" : "";//单据类型
            srm_Pr.supplier_type = supplier.supplier_type;
            srm_Pr.IsRequireGoods = supplier.IsRequireGoods;
            if (supplier.supplier_type == "VMI")
            {
                srm_Pr.IsRequireGoods = 1;
                srm_Pr.pr_order_type = "K";
            }
            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 = lack_qty;
            ////数量圆整 按最小包装量向上圆整
            //if (supplier.packaging_qty.GetValueOrDefault() != 0)
            //{
            //    decimal count = Math.Ceiling(lack_qty / supplier.packaging_qty.GetValueOrDefault());
            //    qty = count * supplier.packaging_qty.GetValueOrDefault();
            //}
            ////判断最小起订量
            //qty = qty > supplier.qty_min.GetValueOrDefault() ? qty : supplier.qty_min.GetValueOrDefault();
            srm_Pr.pr_rqty = lack_qty;//需求数量
            srm_Pr.pr_aqty = lack_qty;//申请数量
            srm_Pr.pr_sqty = lack_qty;//建议数量
            srm_Pr.icitem_id = returnlist.item_id;//物料id
            srm_Pr.icitem_name = returnlist.item_name;//物料名称
            srm_Pr.num = returnlist.num;
            if (plan_date != null)
            {
                //-1为提前一天准备
                srm_Pr.pr_sarrive_date = plan_date.GetValueOrDefault().AddDays(-1 - (int)(Math.Ceiling(plan.clean_leadtime.GetValueOrDefault())));
                srm_Pr.pr_ssend_date = srm_Pr.pr_sarrive_date.Value.AddDays(-(int)Math.Ceiling(supplier.lead_time.GetValueOrDefault()));//系统建议下单日期
                if (srm_Pr.pr_ssend_date < DateTime.Now.Date.AddDays(1))
                {
                    //如果建议下单日期为今天或者过去，则代表物料需求供应时间不够，则需要标记此物料时间不足。
                    var timeSp = DateTime.Now - srm_Pr.pr_ssend_date.Value;
                    returnlist.pre_time = timeSp.Days + 1;
                }
            }
            else
            {
                srm_Pr.pr_ssend_date = DateTime.Now.Date.AddDays(1);//系统建议下单日期
                srm_Pr.pr_sarrive_date = DateTime.Now.AddDays((double)supplier.lead_time.GetValueOrDefault());//系统建议到达日期（建议到货日期）
            }
            sRMPR.totalLeadTime = (int)Math.Ceiling(supplier.lead_time.GetValueOrDefault());
            srm_Pr.pr_sysprice = supplier.order_price;//系统价格（含税）
            srm_Pr.pr_orderprice = lack_qty * supplier.order_price;//订单价格（含税）
            srm_Pr.pr_price = supplier.netpurchase_price;//采购净价（不含税）
            srm_Pr.pr_rate = supplier.taxrate;//税率
            srm_Pr.pr_unit = returnlist.unit;//单位
            srm_Pr.state = 1;//状态
            srm_Pr.old_apply_aqty = 0;//已申请数量
            srm_Pr.pr_type = orderType;//申请类型
            srm_Pr.currencytype = supplier.currency_type == null ? 1 : supplier.currency_type.Value;//币种
            srm_Pr.secInv_ratio = plan.secinv_ratio;//安全库存触发采购比例
            srm_Pr.tenant_id = companyId.GetValueOrDefault();
            srm_Pr.company_id = companyId;
            srm_Pr.factory_id = factoryid;
            srm_Pr.bang_id = bangId;
            if (sentrys != null)
            {
                srm_Pr.sentry_id = sentrys.Id;
            }
            decimal? totalLeadTime = supplier.lead_time.GetValueOrDefault();//plan.transportation_leadtime + plan.stock_leadtime + plan.production_leadtime + plan.order_leadtime;
            srm_Pr.totalLeadTime = totalLeadTime;
            srm_Pr.create_time = DateTime.Now;
            srm_Pr.create_by_name = "admin";
            srm_Pr.update_time = DateTime.Now;
            srm_Pr.update_by_name = "admin";
            sRMPR.srm_Pr_Main.Add(srm_Pr);
            quarter_srm_pr_mains.Add(srm_Pr);

            if (sRMPR.srm_Pr_Main.Any())
            {
                sRMPR.srm_Pr_Main.OrderBy(x => x.totalLeadTime.GetValueOrDefault()).ThenBy(x => x.pr_orderprice.GetValueOrDefault()).First().isbestoptions = true;
            }
            sRMPR.item_no = returnlist.num;
            sRMPR.orderentry_id = returnlist.sentry_id;
            sRMPR.lastStartTmie = sRMPR.srm_Pr_Main.Max(x => x.pr_sarrive_date.GetValueOrDefault());//加上提前期和备料期，得到齐套时间

            //生成mo_srm_po_occupy采购占用表数据。 
            mo_srm_po_occupy srm_Po_Occupy = new mo_srm_po_occupy();
            srm_Po_Occupy.GenerateNewId(help.NextId());
            srm_Po_Occupy.mysql_id = help.NextId();
            srm_Po_Occupy.bang_id = bangId;
            srm_Po_Occupy.polist_id = srm_Pr.mysql_id;
            if (sentrys != null)
            {
                srm_Po_Occupy.eid = sentrys.Id;
                srm_Po_Occupy.bill_no = sentrys.seorder_id;
                srm_Po_Occupy.entry_id = sentrys.entry_seq.GetValueOrDefault();
                srm_Po_Occupy.org_id = sentrys.org_id;
            }
            if (mes_morder != null)
            {
                srm_Po_Occupy.morder_id = mes_morder.Id;
                srm_Po_Occupy.morder_mo = mes_morder.morder_no;
            }
            srm_Po_Occupy.qty = lack_qty;
            srm_Po_Occupy.type = MorderEnum.Zyjc_Type;//TODO:类型未知
            srm_Po_Occupy.stime = srm_Pr.pr_ssend_date;
            srm_Po_Occupy.etime = srm_Pr.pr_sarrive_date;
            srm_Po_Occupy.state = 1;
            srm_Po_Occupy.company_id = param.company_id;//取销售子表企业ID
            srm_Po_Occupy.factory_id = param.factoryId;
            srm_Po_OccupiesInsert.Add(srm_Po_Occupy);
            return sRMPR;
        }*/


        // 生成订单编号 字母+年月日+8位随机数+时间戳
        public string getOrderNum(string preCode)
        {
            string Dates = DateTime.Now.ToString("yyyyMMdd");//获取当前时间
            Random Rdm = new Random(Guid.NewGuid().GetHashCode());//随机数
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);//时间戳
            string newts = Convert.ToInt64(ts.TotalMilliseconds).ToString();//时间戳          
            string new_orderNum = preCode + Dates + Rdm.Next(0, 100000000) + newts;
            return new_orderNum;
        }

        /// <summary>
        /// 生成委外工单
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="factoryid"></param>
        private mo_mes_oorder CreateMesOOder(BomChildExamineDto returnlist, decimal lack_qty, long? companyId, long factoryid, long bangId, List<ICItemLeadTimeDto> iCItemLeadTimes, List<mo_srm_purchase> supplierList, DateTime deliveryDate)
        {
            mo_mes_oorder oOrder = new mo_mes_oorder();
            oOrder.GenerateNewId(help.NextId());
            oOrder.mysql_id = help.NextId();
            oOrder.oorder_no = getOrderNum("WW");//生产工单编号
            oOrder.oorder_type = "委外工单";//生产工单类型
            oOrder.oorder_date = DateTime.Now;//委外订单日期
            oOrder.oorder_state = "已提交";//订单状态
            oOrder.ooentry_prd = 10000;//生产组织
            oOrder.ooentry_prdname = "1000";//生产组织名称
            oOrder.ooentry_wrkc = 10000;//工作中心id
            oOrder.ooentry_wrkcname = "10001";//工作中心名称
            oOrder.planner_num = "wwww";//计划员工号
            oOrder.planner_name = "qqq";//计划员名称

            oOrder.ooentry_etime = deliveryDate.AddDays(-1);//计划完工日期
            oOrder.product_code = returnlist.item_number;//产品代码
            oOrder.ffms_number = "1000";//fms旧料号
            oOrder.product_name = returnlist.item_name;//产品名称
            oOrder.specification_model = returnlist.model;//规格型号
            oOrder.bom_number = returnlist.bom_number;//bom编码
            oOrder.unit = returnlist.unit;//单位
            oOrder.morder_progress = "";//工单进度
            oOrder.morder_production_number = lack_qty;//工单生产数量(计划数量)
            oOrder.need_number = lack_qty;//需求数量
            oOrder.remaining_number = lack_qty;//剩余可用数量
            oOrder.work_number = 0;//报工数量
            oOrder.inspection_number = 0;//报检数量
            oOrder.qualified_number = 0;//合格数量
            oOrder.inventory_number = 0;//入库数量
            oOrder.notice_qty = 0;//已开通知单数量
            oOrder.moentry_on = 1;//启动状态
                                  //oOrder.start_time = DateTime.Now;//开始时间
                                  //oOrder.pause_time = DateTime.Now;//最近暂停时间
                                  //oOrder.restart_time = DateTime.Now;//最近重启时间
            oOrder.project_name = returnlist.item_name;//项目名称
            oOrder.sent_status = 1;//发料状态 1-待发料  2-已发料
            oOrder.production_unit = returnlist.unit;//加工单位
            oOrder.production_unit_code = "";//加工单位编码
            oOrder.need_icitem_status = 1;//所需物料是否充足  1-充足 0-缺料
            oOrder.company_id = companyId;
            oOrder.factory_id = factoryid;
            oOrder.bang_id = bangId;
            oOrder.sentry_id = returnlist.sentry_id;
            oOrder.create_time = DateTime.Now;
            oOrder.create_by_name = "admin";
            oOrder.update_time = DateTime.Now;
            oOrder.update_by_name = "admin";
            return oOrder;
            //_mes_oorder.InsertOne(oOrder);
        }

        /// <summary>
        /// 计算在途
        /// </summary>
        public decimal CalcInTransit(crm_seorderentry sentrys, BomChildExamineDto item, long bangid, DateTime plan_date, decimal suplack_qty, long? supplier_id)
        {
            if (LongPeriod)
            {
                return 0;
            }
            _purchaseOrderAppService.mo_Srm_Po_Lists = srm_Po_Lists; //采购明细
            _purchaseOrderAppService.srm_Po_Occupies = srm_Po_Occupies; //采购明细
            _purchaseOrderAppService.srm_Pr_Mains = srm_Pr_Mains;//在途PR
            _purchaseOrderAppService.mes_morder = mes_morder;//当前工单传递进去。
            _purchaseOrderAppService.scm_Jhjh_Jqs = scm_Jhjh_Jqs;//采购交期回复
            _purchaseOrderAppService.scm_Shdzbs = scm_Shdzbs;//送货单
            _purchaseOrderAppService.scm_ShdzbJYs = scm_ShdzbJYs;//送货单
            DateTime endTime = plan_date;
            if (ScheduleAgreement)
            {
                //启用计划协议时，默认修改时间为最大
                endTime = plan_date.AddYears(100);
            }
            List<mo_srm_po_occupy> occupylist = new List<mo_srm_po_occupy>();
            if (param.checkflag || param.checkPlan)
            {
                occupylist = _purchaseOrderAppService.CheckPurchaseOrder(sentrys, item.item_id, suplack_qty, endTime, ic_item_List, supplier_id, bangid);
            }
            else
            {
                occupylist = _purchaseOrderAppService.CheckPurchaseOrderORJQ(sentrys, item.item_id, suplack_qty, DateTime.Today, ic_item_List, supplier_id, bangid);
            }
            decimal occqty = 0;
            decimal fqc_occqty = 0;
            item.kitting_state = 5;
            if (occupylist.Any())
            {
                occqty = occupylist.Where(x=>x.state==1 || x.state == 3).Sum(s => s.qty.GetValueOrDefault());
                fqc_occqty = occupylist.Where(x => x.state == 2).Sum(s => s.qty.GetValueOrDefault());
                var num = occupylist.Max(o => o.state);
                if (num == 3)
                {
                    //承诺交期
                    item.kitting_state = 4;
                }
                else if (num == 2)
                {
                    //在检满足
                    item.kitting_state = 1;
                }
                else
                {
                    //在途满足
                    item.kitting_state = 2;
                }
                item.purchase_occupy_qty += occqty;
                item.fqc_occupy_qty += fqc_occqty;
                //item.lack_qty -= occqty;
                //item.kitting_time = occupylist[0].etime;
                if (occupylist[0].etime > item.kitting_time || item.kitting_time is null)
                {
                    item.kitting_time = occupylist[0].etime;
                }
                occupylist.ForEach(s =>
                {
                    if (mes_morder != null)
                    {
                        s.morder_id = mes_morder.Id;
                        s.morder_mo = mes_morder.morder_no;
                    }
                });
                item.purchase_occupy_list = new List<purchase_occupy>();
                item.fqc_occupy_list = new List<purchase_occupy>();
                occupylist.ForEach(s =>
                {
                    if (mes_morder != null)
                    {
                        s.morder_id = mes_morder.Id;
                        s.morder_mo = mes_morder.morder_no;
                    }
                    purchase_occupy ocp = new purchase_occupy();
                    ocp.id = s.Id;
                    ocp.stime = s.stime;
                    ocp.etime = s.etime;
                    ocp.qty = s.qty;
                    ocp.type = s.type;
                    var polist = srm_Po_Lists.Find(f => f.Id == s.polist_id);
                    if (polist != null)
                    {
                        ocp.po_billno = polist.po_billno;
                    }
                    if (s.state == 2)
                    {
                        item.fqc_occupy_list.Add(ocp);
                    }
                    else
                    {
                        item.purchase_occupy_list.Add(ocp);
                    }
                    
                });
                srm_Po_Occupies.AddRange(occupylist);
                srm_Po_OccupiesInsert.AddRange(occupylist);
            }
            return occqty;
        }

        public SRMPRDto PackageSRMPR(BomChildExamineDto item, long bangid, crm_seorderentry sentrys, DateTime? plan_date, decimal lack_qty, long? supplier_id)
        {
            //采购申请
            var SRMPRDto = CreateSRMPR(item, lack_qty, param.company_id, param.factoryId, bangid, item.erp_cls, leadTimeList, supplierList, ic_item_List, sentrys, plan_date, supplier_id);
            item.purchase_list = new List<purchase>();
            if (SRMPRDto.srm_Pr_Main != null)
            {
                for (int i = 0; i < SRMPRDto.srm_Pr_Main.Count; i++)
                {
                    purchase pur = new purchase();
                    pur.Id = SRMPRDto.srm_Pr_Main[i].Id;
                    pur.pr_billno = SRMPRDto.srm_Pr_Main[i].pr_billno;
                    pur.pr_purchasenumber = SRMPRDto.srm_Pr_Main[i].pr_purchasenumber;
                    pur.pr_purchasename = SRMPRDto.srm_Pr_Main[i].pr_purchasename;
                    pur.pr_rqty = SRMPRDto.srm_Pr_Main[i].pr_rqty;
                    pur.pr_aqty = SRMPRDto.srm_Pr_Main[i].pr_aqty;
                    pur.pr_sqty = SRMPRDto.srm_Pr_Main[i].pr_sqty;
                    pur.pr_parrive_date = SRMPRDto.srm_Pr_Main[i].pr_parrive_date;
                    pur.pr_rarrive_date = SRMPRDto.srm_Pr_Main[i].pr_rarrive_date;
                    pur.pr_pur_affirm_date = SRMPRDto.srm_Pr_Main[i].pr_pur_affirm_date;
                    pur.pr_sysprice = SRMPRDto.srm_Pr_Main[i].pr_sysprice;
                    pur.pr_orderprice = SRMPRDto.srm_Pr_Main[i].pr_orderprice;
                    pur.pr_price = SRMPRDto.srm_Pr_Main[i].pr_price;
                    pur.pr_rate = SRMPRDto.srm_Pr_Main[i].pr_rate;
                    pur.isbestoptions = SRMPRDto.srm_Pr_Main[i].isbestoptions;
                    item.purchase_list.Add(pur);
                }
            }
            if (item.erp_cls == 3)
            {
                item.purchase_qty += lack_qty;
                item.purchase_list = new List<purchase>();
            }
            item.kitting_time = SRMPRDto.lastStartTmie;
            //if (LongPeriod)//虚拟计算不调整齐套时间
            //{
            //    item.kitting_time = SRMPRDto.lastStartTmie;
            //}
            //else if (SRMPRDto.lastStartTmie > item.kitting_time || item.kitting_time is null)
            //{
            //    item.kitting_time = SRMPRDto.lastStartTmie;
            //}
            SRMPRDtoList.Add(SRMPRDto);
            return SRMPRDto;
        }
    }
}