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

using Business.Core.Enum;
using Business.Core.MongoDBHelper;
using Business.Core.Utilities;
using Business.EntityFrameworkCore;
using Business.ResourceExamineManagement.Dto;
using Business.EntityFrameworkCore.SqlRepositories;
using Business.Model.Bang;
using Business.Model.MES.IC;
using Business.Model.Production;
using Business.Model.Sale;
using Business.Model.SRM;
using Business.Model.Tech;
using Business.MongoModel.MES.IC;
using Business.MongoModel.Production;
using Business.MongoModel.SRM;
using Business.MongoModel.Tech;
using Microsoft.EntityFrameworkCore;
using MongoDB.Driver;
using MongoDB.Driver.Linq;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.MultiTenancy;
using EFCore.BulkExtensions;
using Business.Quartz;

namespace Business.ResourceExamineManagement
{
    /// <summary>
    /// 资源检查
    /// </summary>
    //[Authorize(BusinessPermissions.ResourceExamine.Default)]
    public class ResourceExamineAppService : ApplicationService, IResourceExamineAppService, ITransientDependency
    {
        #region 服务
        SnowFlake help = new SnowFlake();
        private readonly ICurrentTenant _currentTenant;
        /// <summary>
        /// 工艺路径
        /// </summary>
        private readonly IMongoDB<mo_mes_technique> _mes_technique;

        /// <summary>
        /// 工序
        /// </summary>
        private readonly IMongoDB<mo_mes_process> _mes_process;

        /// <summary>
        /// 工艺关联工序
        /// </summary>
        private readonly IMongoDB<mo_mes_tech_process> _mes_tech_process;


        /// <summary>
        /// 工艺工序关联工位
        /// </summary>
        private readonly IMongoDB<mo_mes_tech_proc_workshop> _mes_tech_proc_workshop;

        /// <summary>
        /// 物料占用记录
        /// </summary>
        private readonly IMongoDB<mo_ic_item_stockoccupy> _ic_item_stockoccupy;

        /// <summary>
        /// 物料详情
        /// </summary>
        private readonly IMongoDB<mo_ic_item> _ic_item;
        private IRepository<ic_item, long> _mysql_ic_item;

        /// <summary>
        /// 物料BOM
        /// </summary>
        private readonly IMongoDB<mo_ic_bom> _ic_bom;
        private IRepository<ic_bom, long> _mysql_ic_bom;
        /// <summary>
        /// 物料BOM明细
        /// </summary>
        private readonly IMongoDB<mo_ic_bom_child> _ic_bom_child;
        private IRepository<ic_bom_child, long> _mysql_ic_bom_child;

        /// <summary>
        /// 物料库存表
        /// </summary>
        private readonly IMongoDB<mo_ic_item_stock> _ic_item_stock;
        private IRepository<ic_item_stock, long> _mysql_ic_item_stock;

        /// <summary>
        /// 物料采购计划表
        /// </summary>
        private readonly IMongoDB<mo_ic_plan> _ic_plan;
        private IRepository<ic_plan, long> _mysql_ic_plan;

        /// <summary>
        /// 物料工厂明细表
        /// </summary>
        private readonly IMongoDB<mo_ic_factory_details> _ic_factory_details;
        private IRepository<ic_factory_details, long> _mysql_ic_factory_details;

        /// <summary>
        /// 物料采购报价单
        /// </summary>
        private readonly IMongoDB<mo_srm_purchase> _srm_purchase;
        private IRepository<srm_purchase, long> _mysql_srm_purchase;

        /// <summary>
        /// 采购申请单
        /// </summary>
        private readonly IMongoDB<mo_srm_pr_main> _srm_pr_main;
        private IRepository<srm_pr_main, long> _mysql_srm_pr_main;

        /// <summary>
        /// 采购订单表
        /// </summary>
        private readonly IMongoDB<mo_srm_po_main> _srm_po_main;
        private IRepository<srm_po_main, long> _mysql_srm_po_main;

        /// <summary>
        /// 采购订单明细表
        /// </summary>
        private readonly IMongoDB<mo_srm_po_list> _srm_po_list;
        private IRepository<srm_po_list, long> _mysql_srm_po_list;

        /// <summary>
        /// 采购订单占用详情
        /// </summary>
        private readonly IMongoDB<mo_srm_po_occupy> _srm_po_occupy;
        private IRepository<srm_po_occupy, long> _mysql_srm_po_occupy;

        /// <summary>
        /// 委外工单
        /// </summary>
        private readonly IMongoDB<mo_mes_oorder> _mes_oorder;
        private IRepository<mes_oorder, long> _mysql_mes_oorder;

        private IRepository<b_bom_pretreatment, long> _mysql_b_bom_pretreatment;

        private IRepository<b_examine_result, long> _mysql_examine_result;
        private IRepository<b_bom_child_examine, long> _mysql_bom_child_examine;
        private IRepository<b_mo_occupy, long> _mysql_mo_occupy;
        private IRepository<b_mo_order, long> _mysql_mo_order;
        private IRepository<b_ooder, long> _mysql_ooder;
        private IRepository<b_purchase, long> _mysql_purchase;
        private IRepository<b_purchase_occupy, long> _mysql_purchase_occupy;

        /// <summary>
        /// 物料质检表
        /// </summary>
        private readonly IMongoDB<mo_ic_check> _ic_check;
        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<mo_ic_substitute> _ic_substitute;
        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<mo_ic_substitute_group> _ic_substitute_group;
        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<mo_ic_substitute_group_detail> _ic_substitute_group_detail;

        /// <summary>
        /// 生产工单主表
        /// </summary>
        private readonly IMongoDB<mo_mes_morder> _mes_morder;
        /// <summary>
        /// 生产工单子表
        /// </summary>
        private readonly IMongoDB<mo_mes_moentry> _mes_moentry;

        /// <summary>
        /// 在制工单占用记录表
        /// </summary>
        private readonly IMongoDB<mo_mes_mooccupy> _mes_mooccupy;
        /// <summary>
        /// mysql在制工单占用表
        /// </summary>
        private readonly IRepository<mes_mooccupy, long> _mysql_mes_mooccupy;
        /// <summary>
        /// 销售订单
        /// </summary>
        private readonly IRepository<crm_seorder, long> _mysql_crm_seorder;
        /// <summary>
        /// 销售订单明细
        /// </summary>
        private readonly IRepository<crm_seorderentry, long> _mysql_crm_seorderentry;

        /// <summary>
        /// 生产工单主表
        /// </summary>
        private readonly IRepository<mes_morder, long> _mysql_mes_morder;
        /// <summary>
        /// 生产工单子表
        /// </summary>
        private readonly IRepository<mes_moentry, long> _mysql_mes_moentry;

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

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

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

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

        /// <summary>
        /// 计算BOM平铺物料情况
        /// </summary>
        private readonly CalcBomViewAppService _CalcBomViewAppService;

        private List<ICItemLeadTimeDto> leadTimeList;

        private List<mo_srm_purchase> supplierList;

        private List<mo_ic_plan> planList;

        private readonly BusinessBangDbContext _businessBangDbContext;
        private readonly BusinessDbContext _businessDbContext;
        private readonly ISqlRepository<TagMaster> _tagMasterRepository;

        private readonly ProductionScheduleAppService _productionScheduleAppService;
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="icitem"></param>
        /// <param name="icbom"></param>
        public ResourceExamineAppService(
            IMongoDB<mo_mes_technique> mes_technique,
            IMongoDB<mo_mes_process> mes_process,
            IMongoDB<mo_mes_tech_process> mes_tech_process,
            IMongoDB<mo_mes_tech_proc_workshop> mes_tech_proc_workshop,
            IMongoDB<mo_ic_item> ic_item,
            IMongoDB<mo_ic_bom> ic_bom,
            IMongoDB<mo_ic_bom_child> ic_bom_child,
            IMongoDB<mo_ic_item_stock> ic_item_stock,
            IMongoDB<mo_ic_check> ic_check,
            IMongoDB<mo_ic_factory_details> ic_factory_details,
            IMongoDB<mo_mes_oorder> mes_oorder,
            IMongoDB<mo_srm_pr_main> srm_pr_main,
            IMongoDB<mo_srm_po_main> srm_po_main,
            IMongoDB<mo_srm_po_list> srm_po_list,
            IMongoDB<mo_srm_po_occupy> srm_po_occupy,
            IMongoDB<mo_srm_purchase> srm_purchase,
            IMongoDB<mo_ic_plan> ic_plan,
            IMongoDB<mo_ic_substitute> ic_substitute,
            IMongoDB<mo_ic_substitute_group> ic_substitute_group,
            IMongoDB<mo_ic_substitute_group_detail> ic_substitute_group_detail,
            IMongoDB<mo_mes_morder> mes_morder,
            IMongoDB<mo_mes_moentry> mes_moentry,
            IMongoDB<mo_mes_mooccupy> mes_mooccupy,
            IMongoDB<mo_ic_item_stockoccupy> ic_item_stockoccupy,
            IRepository<ic_item, long> mysql_ic_item,
            IRepository<ic_bom, long> mysql_ic_bom,
            IRepository<ic_bom_child, long> mysql_ic_bom_child,
            IRepository<mes_technique, long> mysql_mes_technique,
            IRepository<crm_seorder, long> mysql_crm_seorder,
            IRepository<crm_seorderentry, long> mysql_crm_seorderentry,
            IRepository<ic_item_stock, long> mysql_ic_item_stock,
            IRepository<ic_factory_details, long> mysql_ic_factory_details,
            IRepository<mes_oorder, long> mysql_mes_oorder,
            IRepository<srm_pr_main, long> mysql_srm_pr_main,
            IRepository<mes_mooccupy, long> mysql_mes_mooccupy,
            IRepository<mes_morder, long> mysql_mes_morder,
            IRepository<mes_moentry, long> mysql_mes_moentry,
            IRepository<mes_process, long> mysql_mes_process,
            IRepository<mes_tech_process, long> mysql_mes_tech_process,
            IRepository<srm_po_main, long> mysql_srm_po_main,
            IRepository<srm_po_list, long> mysql_srm_po_list,
            IRepository<srm_po_occupy, long> mysql_srm_po_occupy,
            IRepository<srm_purchase, long> mysql_srm_purchase,
            IRepository<ic_plan, long> mysql_ic_plan,
            IRepository<b_examine_result, long> mysql_examine_result,
            IRepository<b_bom_child_examine, long> mysql_bom_child_examine,
            IRepository<b_mo_occupy, long> mysql_mo_occupy,
            IRepository<b_mo_order, long> mysql_mo_order,
            IRepository<b_ooder, long> mysql_ooder,
            IRepository<b_purchase, long> mysql_purchase,
            IRepository<b_purchase_occupy, long> mysql_purchase_occupy,
            IRepository<b_bom_pretreatment, long> mysql_b_bom_pretreatment,
            ISqlRepository<TagMaster> tagMasterRepository,
            PretreatmentAppService pretreatmentAppService,
            CalcBomViewAppService calcbomviewAppService,
            PurchaseOrderAppService purchaseOrderAppService,
            ICurrentTenant currentTenant,
            MorderAppService morderAppService,
            BusinessBangDbContext businessBangDbContext,
            BusinessDbContext businessDbContext,
            ProductionScheduleAppService productionScheduleAppService
            )
        {
            _mes_technique = mes_technique;
            _mes_process = mes_process;
            _mes_tech_process = mes_tech_process;
            _mes_tech_proc_workshop = mes_tech_proc_workshop;
            _ic_item = ic_item;
            _ic_bom = ic_bom;
            _ic_bom_child = ic_bom_child;
            _ic_item_stock = ic_item_stock;
            _ic_check = ic_check;
            _ic_factory_details = ic_factory_details;
            _mes_oorder = mes_oorder;
            _srm_pr_main = srm_pr_main;
            _srm_po_main = srm_po_main;
            _srm_po_list = srm_po_list;
            _srm_po_occupy = srm_po_occupy;
            _srm_purchase = srm_purchase;
            _ic_plan = ic_plan;
            _ic_substitute = ic_substitute;
            _ic_substitute_group = ic_substitute_group;
            _ic_substitute_group_detail = ic_substitute_group_detail;
            _mes_morder = mes_morder;
            _mes_moentry = mes_moentry;
            _mes_mooccupy = mes_mooccupy;
            _ic_item_stockoccupy = ic_item_stockoccupy;
            _mysql_ic_item = mysql_ic_item;
            _mysql_ic_bom = mysql_ic_bom;
            _mysql_ic_bom_child = mysql_ic_bom_child;
            _mysql_crm_seorder = mysql_crm_seorder;
            _mysql_crm_seorderentry = mysql_crm_seorderentry;
            _mysql_ic_item_stock = mysql_ic_item_stock;
            _mysql_ic_factory_details = mysql_ic_factory_details;
            _mysql_mes_oorder = mysql_mes_oorder;
            _mysql_srm_pr_main = mysql_srm_pr_main;
            _mysql_mes_mooccupy = mysql_mes_mooccupy;
            _mysql_mes_morder = mysql_mes_morder;
            _mysql_mes_moentry = mysql_mes_moentry;
            _mysql_srm_po_main = mysql_srm_po_main;
            _mysql_srm_po_list = mysql_srm_po_list;
            _mysql_srm_po_occupy = mysql_srm_po_occupy;
            _mysql_srm_purchase = mysql_srm_purchase;
            _mysql_ic_plan = mysql_ic_plan;
            _mysql_examine_result = mysql_examine_result;
            _mysql_bom_child_examine = mysql_bom_child_examine;
            _mysql_mo_occupy = mysql_mo_occupy;
            _mysql_mo_order= mysql_mo_order;
            _mysql_ooder=mysql_ooder;
            _mysql_purchase = mysql_purchase;
            _mysql_purchase_occupy = mysql_purchase_occupy;
            _mysql_b_bom_pretreatment = mysql_b_bom_pretreatment;
            _tagMasterRepository = tagMasterRepository;
            _pretreatmentAppService = pretreatmentAppService;
            _CalcBomViewAppService = calcbomviewAppService;
            _purchaseOrderAppService = purchaseOrderAppService;
            _currentTenant = currentTenant;
            _morderAppService = morderAppService;
            _businessBangDbContext = businessBangDbContext;
            _businessDbContext = businessDbContext;
            _productionScheduleAppService= productionScheduleAppService;
        }
        #endregion

        /// <summary>
        /// 资源检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<string> ReceiveResult(ResourceCheckInputDto input)
        {
            //TagMaster tagMaster=new TagMaster();
            //tagMaster.Domain = "1000";
            //tagMaster.Nbr = "20230505002"+DateTime.Now.Second.ToString();
            //tagMaster.Type = "Q";
            //tagMaster.Print = false;
            //tagMaster.Void= false;
            //tagMaster.Posted= false;
            //tagMaster.BusinessID = 0;
            //tagMaster.CreateUser = "admin";
            //tagMaster.UpdateUser = "admin";
            //tagMaster.CreateTime = DateTime.Now;
            //tagMaster.UpdateTime= DateTime.Now;
            //tagMaster.IsActive= true;
            //tagMaster.IsConfirm= true;
            //tagMaster.IsChanged= true;
            //tagMaster.InvTitle = "线边库存核查";
            //await _tagMasterRepository.Insert(tagMaster);
            //var test= _tagMasterRepository.SelectDataBaseBySql("Select * from TagMaster Where Nbr='202305050029'", "TagMaster");
            //return JsonConvert.SerializeObject(test);
            //资源检查入参全局变量赋值
            param.sorderId = input.sorderId;
            param.tenantId = input.tenantId;
            param.factoryId = input.factoryId;
            param.checkflag = true;

            //资源检查结果
            PschedDto rtn = new PschedDto();
            rtn.sorderid = input.sorderId;
            //资源检查明细list
            List<ExamineResult> examines = new List<ExamineResult>();
            ExamineResult dtl;
            /*if (input.sorderId == 123)
            {
                Random rd = new Random();

                List<ic_item_stock> itemstocklist = new List<ic_item_stock>();
                var iclist = _mysql_ic_item.GetListAsync(s => s.tenant_id == 101).Result;
                iclist.ForEach(s => {
                    ic_item_stock stock = new ic_item_stock();
                    stock.GenerateNewId(help.NextId());
                    stock.icitem_id = s.Id;
                    stock.icitem_name = s.name;
                    stock.sqty = rd.Next(0, 300);
                    stock.tenant_id = s.tenant_id;
                    stock.factory_id = s.factory_id;
                    itemstocklist.Add(stock);
                });
                await _businessDbContext.ic_item_stock.BulkInsertAsync(itemstocklist, options => options.InsertKeepIdentity = true);
                return "ok";
            }*/

            //生成当前计算bangid
            long bangid = help.NextId();

            //获取订单数据
            crm_seorder sorder = _mysql_crm_seorder.GetListAsync(p => p.tenant_id == input.tenantId && p.factory_id == input.factoryId && p.Id == input.sorderId && !p.IsDeleted).Result.FirstOrDefault();
            if (sorder == null)
            {
                new NLogHelper("ResourceExamineAppService").WriteLog("ReceiveResult", "订单数据不存在", _currentTenant.Id.ToString());
                throw new NotImplementedException("订单数据不存在！");
            }
            //获取订单行数据
            List<crm_seorderentry> sentrys = await _mysql_crm_seorderentry.GetListAsync(p => p.tenant_id == input.tenantId && p.factory_id == input.factoryId && p.seorder_id == input.sorderId && !p.IsDeleted);

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


            //数据库快照-同步mysql库数据到mongoDB中
            await DbSnapShot(input.tenantId, input.factoryId, bangid);

            //通过订单行的产品代码获取物料BOM数据
            //FilterDefinition<ic_bom> filter = Builders<ic_bom>.Filter.In(s => s.bom_number, sentrys.Select(m => m.bom_number).ToList());
            //List<ic_bom> boms = _ic_bom.GetManyByIds(filter).Result.Where(p => p.factory_id == input.factoryId && p.tenant_id == input.tenantId && !p.IsDeleted).ToList();
            List<mo_ic_bom> boms = _ic_bom.Find(p => sentrys.Select(m => m.item_number).Contains(p.item_number) && p.factory_id == input.factoryId && p.tenant_id == input.tenantId && !p.IsDeleted).Result.ToList();
            ////物料bom
            //List<mo_ic_bom> bomlist = new List<mo_ic_bom>();
            ////物料bom明细
            //List<mo_ic_bom_child> bomchildlist = new List<mo_ic_bom_child>();
            //物料信息
            List<mo_ic_item> icitemlist = new List<mo_ic_item>();
            //替代关系
            //List<mo_ic_substitute> sublist = new List<mo_ic_substitute>();
            //List<mo_ic_substitute_group> suballlist = new List<mo_ic_substitute_group>();
            //List<mo_ic_substitute_group_detail> subdtllist = new List<mo_ic_substitute_group_detail>();
            //物料库存表
            List<mo_ic_item_stock> stocklist = new List<mo_ic_item_stock>();
            //物料占用记录
            List<mo_ic_item_stockoccupy> sklist = new List<mo_ic_item_stockoccupy>();
            
            var pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            List<mo_ic_bom> autoCreates = new List<mo_ic_bom>();
            boms.ForEach(p => {
                if (!pretreatments.Where(s => s.sourceid == p.mysql_id).Any())
                {
                    autoCreates.Add(p);
                }
            });
            if (autoCreates.Any())
            {
                AutoCreateBomBill(autoCreates);
                pretreatments = _mysql_b_bom_pretreatment.GetListAsync(s => boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;
            }

            DataInitialization(boms, bangid, sorder, icitemlist, stocklist, pretreatments);
            foreach (var item in sentrys)
            {
                //工单资源检查信息
                dtl = new ExamineResult();
                dtl.sorderid = rtn.sorderid;
                dtl.bill_no = sorder.bill_no;
                dtl.sentry_id = item.Id;
                dtl.entry_seq = item.entry_seq;
                //TODO:最早开始时间默认3天后(后期调整)
                dtl.earliest_times = DateTime.Now.Date.AddDays(3);
                dtl.need_qty = item.qty.GetValueOrDefault();
                dtl.need_time = item.plan_date;
                //获取当前物料bom数据
                var childBom = boms.Where(p => p.item_number == item.item_number).FirstOrDefault();
                dtl.bom_number = childBom.bom_number;

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

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

                getBomList.ForEach(s => s.sentry_id = item.Id);
                //库存初始化
                _CalcBomViewAppService.BomStock(getBomList, stocklist, bangid);
                //计算
                _CalcBomViewAppService.CalcView(getBomList, bangid, item.qty.GetValueOrDefault(), item.plan_date, sklist, item, icitemlist);

                //TODO:最晚开始时间
                var curFacDtl = leadTimeList.FirstOrDefault(p => p.item_id == childBom.icitem_id);
                //最晚开工时间=订单行客户要求交期-运输提前期-库存提前期-生产提前期-下单提前期-生产时间
                dtl.latest_times = item.plan_date.GetValueOrDefault().AddDays(-Convert.ToDouble(curFacDtl?.transportation_leadtime.GetValueOrDefault() + curFacDtl?.stock_leadtime.GetValueOrDefault() + curFacDtl?.production_leadtime.GetValueOrDefault() + curFacDtl?.order_leadtime.GetValueOrDefault() + _CalcBomViewAppService.ProductionTimeDay));
                //物料齐套时间
                dtl.kitting_times = getBomList.Where(p => p.is_use).OrderByDescending(m => m.kitting_time).First().kitting_time.GetValueOrDefault();
                //TODO:最早开始时间默认3天后(后期调整,因为要计算排产，计算产能这一类，才能得到开工时间)
                dtl.earliest_times = dtl.kitting_times.AddDays(1);

                //替代关系展开list
                dtl.BomChildExamineList = getBomList;
                //添加订单行开工信息
                examines.Add(dtl);
            }
            //批量保存 后期考虑子工单
            if (_CalcBomViewAppService.mordersInsertList.Any())
            {
                await _mes_morder.InsertMany(_CalcBomViewAppService.mordersInsertList);
                var mesorders = ObjectMapper.Map<List<mo_mes_morder>, List<mes_morder>>(_CalcBomViewAppService.mordersInsertList);
                _businessDbContext.BulkInsert(mesorders);
                rtn.mordersList = _CalcBomViewAppService.mordersInsertList;
            }
            if (_CalcBomViewAppService.mooccupyAllInsertList.Any())
            {
                await _mes_mooccupy.InsertMany(_CalcBomViewAppService.mooccupyAllInsertList);
                rtn.mooccupyAllList = _CalcBomViewAppService.mooccupyAllInsertList;
            }
            if (_CalcBomViewAppService.moentriesList.Any())
            {
                await _mes_moentry.InsertMany(_CalcBomViewAppService.moentriesList);
                var mesmoentrys = ObjectMapper.Map<List<mo_mes_moentry>, List<mes_moentry>>(_CalcBomViewAppService.moentriesList);
                _businessDbContext.BulkInsert(mesmoentrys);
            }
            if (_CalcBomViewAppService.orderList.Any())
            {
                await _mes_oorder.InsertMany(_CalcBomViewAppService.orderList);
                var ooders = ObjectMapper.Map<List<mo_mes_oorder>, List<mes_oorder>>(_CalcBomViewAppService.orderList);
                _businessDbContext.BulkInsert(ooders);
                rtn.order_list = _CalcBomViewAppService.orderList;
            }
            if (sklist.Any())
            {
                sklist.ForEach(s => s.id = help.NextId());
                await _ic_item_stockoccupy.InsertMany(sklist);
            }
            if (_CalcBomViewAppService.srm_Po_OccupiesInsert.Any())
            {
                await _srm_po_occupy.InsertMany(_CalcBomViewAppService.srm_Po_OccupiesInsert);
            }
            if (_CalcBomViewAppService.SRMPRDtoList.Any())
            {
                var prlist = _CalcBomViewAppService.SRMPRDtoList.Where(f => f.srm_Pr_Main != null).Select(s => s.srm_Pr_Main).ToList();
                List<mo_srm_pr_main> list = new List<mo_srm_pr_main>();
                foreach (var pr in prlist)
                {
                    foreach (var item in pr)
                    {
                        list.Add(item);
                    }
                }
                if (list.Any())
                {
                    await _srm_pr_main.InsertMany(list);
                    var pr_mainlist = ObjectMapper.Map<List<mo_srm_pr_main>, List<srm_pr_main>>(list);
                    _businessDbContext.BulkInsert(pr_mainlist);
                }
                rtn.srm_pr_list = _CalcBomViewAppService.SRMPRDtoList;
            }
            rtn.examines = examines;
            rtn.item_stockoccupy_list = sklist;

            //检查结果写入数据库
            var b_Examine_Results = ObjectMapper.Map<List<ExamineResult>, List<b_examine_result>>(rtn.examines);
            List<b_examine_result> examineList = new List<b_examine_result>();
            List<b_bom_child_examine> bomExamineList = new List<b_bom_child_examine>();
            List<b_mo_occupy> mooccupyList = new List<b_mo_occupy>();
            List<b_mo_order> moorderList = new List<b_mo_order>();
            List<b_ooder> ooderList = new List<b_ooder>();
            List<b_purchase> purchaseList = new List<b_purchase>();
            List<b_purchase_occupy> purchaseoccupyList = new List<b_purchase_occupy>();

            foreach (var ex in rtn.examines)
            {
                var b_ex = ObjectMapper.Map<ExamineResult, b_examine_result>(ex);
                b_ex.GenerateNewId();// = help.NextId();
                b_ex.create_time = DateTime.Now;
                b_ex.tenant_id = param.tenantId;
                b_ex.factory_id = param.factoryId;
                examineList.Add(b_ex);
                ex.BomChildExamineList.ForEach(s => {
                    var bc_ex = ObjectMapper.Map<BomChildExamineDto, b_bom_child_examine>(s);
                    bc_ex.GenerateNewId(help.NextId());
                    bc_ex.examine_id = b_ex.Id;
                    bc_ex.tenant_id = param.tenantId;
                    bc_ex.factory_id = param.factoryId;
                    bc_ex.create_time = DateTime.Now;
                    bomExamineList.Add(bc_ex);

                    if(s.mo_occupy_list != null)
                    {
                        var olist = ObjectMapper.Map<List<mo_occupy>, List<b_mo_occupy>>(s.mo_occupy_list);
                        olist.ForEach(o => { o.bom_child_examine_id = bc_ex.Id; o.tenant_id = param.tenantId;
                            o.factory_id = param.factoryId;
                        });
                        mooccupyList.AddRange(olist);
                    }
                    if (s.make_list != null)
                    {
                        var mlist = ObjectMapper.Map<List<moorder>, List<b_mo_order>>(s.make_list);
                        mlist.ForEach(o => { o.bom_child_examine_id = bc_ex.Id; o.tenant_id = param.tenantId;
                            o.factory_id = param.factoryId;
                        });
                        moorderList.AddRange(mlist);
                    }
                    if (s.subcontracting_list != null)
                    {
                        var slist = ObjectMapper.Map<List<ooder>, List<b_ooder>>(s.subcontracting_list);
                        slist.ForEach(o => { o.bom_child_examine_id = bc_ex.Id; o.tenant_id = param.tenantId;
                            o.factory_id = param.factoryId;
                        });
                        ooderList.AddRange(slist);
                    }
                    if (s.purchase_list != null)
                    {
                        var plist = ObjectMapper.Map<List<purchase>, List<b_purchase>>(s.purchase_list);
                        plist.ForEach(o => { o.bom_child_examine_id = bc_ex.Id; o.tenant_id = param.tenantId;
                            o.factory_id = param.factoryId;
                        });
                        purchaseList.AddRange(plist);
                    }
                    if (s.purchase_occupy_list != null)
                    {
                        var purlist = ObjectMapper.Map<List<purchase_occupy>, List<b_purchase_occupy>>(s.purchase_occupy_list);
                        purlist.ForEach(o => { o.bom_child_examine_id = bc_ex.Id; o.tenant_id = param.tenantId;
                            o.factory_id = param.factoryId;
                        });
                        purchaseoccupyList.AddRange(purlist);
                    }
                });
            }
            if (examineList.Any())
            {
                _businessBangDbContext.BulkInsert(examineList);
            }
            if (bomExamineList.Any())
            {
                _businessBangDbContext.BulkInsert(bomExamineList.OrderBy(s => s.num_order).ToList());
            }
            if (mooccupyList.Any())
            {
                _businessBangDbContext.BulkInsert(mooccupyList);
            }
            if (moorderList.Any())
            {
                _businessBangDbContext.BulkInsert(moorderList);
            }
            if (ooderList.Any())
            {
                _businessBangDbContext.BulkInsert(ooderList);
            }
            if (purchaseList.Any())
            {
                _businessBangDbContext.BulkInsert(purchaseList);
            }
            if (purchaseoccupyList.Any())
            {
                _businessBangDbContext.BulkInsert(purchaseoccupyList);
            }
            //清空快照数据
            await ClearSnapShot(bangid);
            //return JsonConvert.SerializeObject(rtn);
            return JsonConvert.SerializeObject("ok");
        }

        /// <summary>
        /// 通过ic_bom获取工艺路径数据
        /// </summary>
        /// <param name="ic_Boms"></param>
        /// <returns></returns>
        public List<mo_mes_technique> GetMesTechniques(List<mo_ic_bom> ic_Boms)
        {
            List<mo_mes_technique> techniques = new List<mo_mes_technique>();
            //foreach (var item in ic_Boms)
            //{
            //    mo_mes_technique entity = _mes_technique.Find(p => p.bom == item.bom_number && p.bomver == item.version && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.FirstOrDefault();
            //    if (entity != null)
            //    {
            //        techniques.Add(entity);
            //    }
            //}
            var builder = Builders<mo_mes_technique>.Filter;
            var filters = new List<FilterDefinition<mo_mes_technique>>();
            ic_Boms?.ForEach(item =>
            {
                var filter = builder.Eq(x => x.bom, item.bom_number)
                & builder.Eq(x => x.bomver, item.version)
                & builder.Eq(x => x.tenant_id, param.tenantId)
                & builder.Eq(x => x.factory_id, param.factoryId)
                & builder.Eq(x => x.IsDeleted, false);
                filters.Add(filter);
            });
            techniques = _mes_technique.Find(builder.Or(filters)).Result;
            return techniques;
        }

        /// <summary>
        /// 递归:获取icbom,icbomchild数据
        /// </summary>
        /// <param name="icBoms"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        public void GetIcBomData(List<mo_ic_bom> icBoms, List<mo_ic_bom> bomlist, List<mo_ic_bom_child> bomchildlist)
        {
            if (icBoms.Count() == 0)
            {
                return;
            }
            //添加物料bom数据
            foreach (var ib in icBoms)
            {
                if (!bomlist.Exists(s => s.mysql_id == ib.mysql_id))
                {
                    bomlist.Add(ib);
                }
            }
            //获取物料bom明细数据
            //List<mo_ic_bom_child> childList = _ic_bom_child.GetManyByCondition(p => icBoms.Select(m => m.mysql_id).Contains(p.bom_id) && p.use_status == 1 && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.ToList();
            List<mo_ic_bom_child> childList = _ic_bom_child.GetManyByCondition(p => icBoms.Select(m => m.mysql_id).Contains(p.bom_id) && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.ToList();
            //没有明细数据,终止
            if (childList.Count == 0)
            {
                return;
            }
            foreach (var bchild in childList)
            {
                if (!bomchildlist.Exists(s => s.mysql_id == bchild.mysql_id))
                {
                    bomchildlist.Add(bchild);
                }
            }
            //通过物料bom明细数据反查物料bom数据
            var boms = _ic_bom.GetManyByCondition(p => childList.Select(m => m.icitem_id).ToList().Contains(p.icitem_id) && p.use_status == 1 && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.ToList();
            foreach (var chd in childList)
            {
                var curBoms = boms.Where(p => p.icitem_id == chd.icitem_id).ToList();
                GetIcBomData(curBoms, bomlist, bomchildlist);
            }
        }
        /// <summary>
        /// 删除旧订单行数据
        /// </summary>
        /// <param name="tenantId"></param>
        /// <param name="factoryId"></param>
        /// <param name="soentry_id"></param>
        /// <returns></returns>
        public async Task DeleteMySqlOldData(List<crm_seorderentry> soentry_id)
        {
            List<long> sentryids = soentry_id.Select(p => p.Id).ToList();
            //删除工单相关表数据
            var mes_moentry = _mysql_mes_moentry.GetListAsync(x => sentryids.Contains(x.soentry_id.Value)).Result;

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

        /// <summary>
        /// 数据库快照
        /// </summary>
        /// <returns></returns>
        public async Task DbSnapShot(long tenantId, long factoryId, long bangid)
        {
            //同步物料库存数据
            var icitemStokc = _mysql_ic_item_stock.GetListAsync(p => p.tenant_id == tenantId && p.factory_id == factoryId).Result;
            if (icitemStokc.Count > 0)
            {
                //设置当前计算bangid
                icitemStokc.ForEach(item => { item.bang_id = bangid; });
                var moIcitemStokc = ObjectMapper.Map<List<ic_item_stock>, List<mo_ic_item_stock>>(icitemStokc);
                moIcitemStokc.ForEach(item => { item.id = help.NextId(); });
                //插入数据
                await _ic_item_stock.InsertMany(moIcitemStokc);
            }
            //在制工单占用记录表
            var mes_mooccupy = _mysql_mes_mooccupy.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (mes_mooccupy.Count > 0)
            {
                mes_mooccupy.ForEach(item => { item.bang_id = bangid; });
                var moMes_mooccupy = ObjectMapper.Map<List<mes_mooccupy>, List<mo_mes_mooccupy>>(mes_mooccupy);
                moMes_mooccupy.ForEach(item => { item.id = help.NextId(); });
                await _mes_mooccupy.InsertMany(moMes_mooccupy);
            }
            //工单主表
            var mes_morder = _mysql_mes_morder.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (mes_morder.Count > 0)
            {
                mes_morder.ForEach(item => { item.bang_id = bangid; });
                var moMes_morder = ObjectMapper.Map<List<mes_morder>, List<mo_mes_morder>>(mes_morder);
                moMes_morder.ForEach(item => { item.id = help.NextId(); });
                await _mes_morder.InsertMany(moMes_morder);
            }
            //工单子表
            var mes_moentry = _mysql_mes_moentry.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (mes_moentry.Count > 0)
            {
                mes_moentry.ForEach(item => { item.bang_id = bangid; });
                var moMes_moentry = ObjectMapper.Map<List<mes_moentry>, List<mo_mes_moentry>>(mes_moentry);
                moMes_moentry.ForEach(item => { item.id = help.NextId(); });
                await _mes_moentry.InsertMany(moMes_moentry);
            }

            //TODO:要不要根据某些条件只同步有效的数据
            //采购订单
            var srm_po_main = _mysql_srm_po_main.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (srm_po_main.Count > 0)
            {
                srm_po_main.ForEach(item => { item.bang_id = bangid; });
                var moSrm_po_main = ObjectMapper.Map<List<srm_po_main>, List<mo_srm_po_main>>(srm_po_main);
                moSrm_po_main.ForEach(item => { item.id = help.NextId(); });
                await _srm_po_main.InsertMany(moSrm_po_main);
            }

            //采购订单明细
            var srm_po_list = _mysql_srm_po_list.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (srm_po_list.Count > 0)
            {
                srm_po_list.ForEach(item => { item.bang_id = bangid; });
                var moSrm_po_list = ObjectMapper.Map<List<srm_po_list>, List<mo_srm_po_list>>(srm_po_list);
                moSrm_po_list.ForEach(item => { item.id = help.NextId(); });
                await _srm_po_list.InsertMany(moSrm_po_list);
            }

            //采购订单占用详情
            var srm_po_occupy = _mysql_srm_po_occupy.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (srm_po_occupy.Count > 0)
            {
                srm_po_occupy.ForEach(item => { item.bang_id = bangid; });
                var moSrm_po_occupy = ObjectMapper.Map<List<srm_po_occupy>, List<mo_srm_po_occupy>>(srm_po_occupy);
                moSrm_po_occupy.ForEach(item => { item.id = help.NextId(); });
                await _srm_po_occupy.InsertMany(moSrm_po_occupy);
            }
        }

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

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

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

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

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

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

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

        /// <summary>
        /// 根据物料id获取物料4个提前期
        /// </summary>
        /// <param name="icItemIds">物料id</param>
        /// <param name="tenantId">企业id</param>
        /// <param name="factoryid">工厂id</param>
        /// <returns></returns>
        private List<ICItemLeadTimeDto> GetLeadTime(List<long> icItemIds, long tenantId, long factoryid)
        {
            ProjectionDefinitionBuilder<mo_ic_factory_details> project = new ProjectionDefinitionBuilder<mo_ic_factory_details>();
            return _ic_factory_details.Find(p => icItemIds.Contains(p.icitem_id) && p.factory_id == factoryid && p.tenant_id == tenantId && !p.IsDeleted,
                project.Include(p => p.icitem_id).Include(p => p.production_leadtime).Include(p => p.stock_leadtime).
                Include(p => p.transportation_leadtime).Include(p => p.order_leadtime).Include(p => p.minorderqty)).Result.
                Select(x => new ICItemLeadTimeDto
                {
                    item_id = x.icitem_id,
                    transportation_leadtime = x.transportation_leadtime,
                    stock_leadtime = x.stock_leadtime,
                    production_leadtime = x.production_leadtime,
                    order_leadtime = x.order_leadtime,
                    minorderqty = x.minorderqty
                }).AsQueryable<ICItemLeadTimeDto>().ToList();
        }

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

        //根据物料id获取物料采购计划表
        private List<mo_ic_plan> GetICPlan(List<long> icItemIds, long tenantId, long factoryid)
        {
            return _ic_plan.Find(p => icItemIds.Contains(p.icitem_id) && p.tenant_id == tenantId && p.factory_id == factoryid && !p.IsDeleted).Result;
        }


        /// <summary>
        /// 检查在途量
        /// </summary>
        /// <param name="returnlist">物料列表</param>
        /// <param name="factoryid">工厂id</param>
        /// <param name="deliveryDate">销售订单交付日期</param>
        /// <returns></returns>
        private async Task<List<ICItemDateDto>> CheckOnOrder(List<BomChildExamineDto> returnlist, long tenantId, long factoryid, DateTime deliveryDate, long bangid)
        {
            //ToDo:企业Id,数据状态过滤以及isdeleted
            var po_list = _srm_po_list.Find(p => returnlist.Select(x => x.item_id).Contains(p.icitem_id.Value) && p.tenant_id == tenantId && p.factory_id == factoryid && p.rarrdate >= DateTime.Now && p.rarrdate < deliveryDate && !p.IsDeleted).Result;
            var itemlist = new List<ICItemDateDto>();//需要生成采购申请单的物料信息
            var leadTimeList = GetLeadTime(returnlist.Select(p => p.item_id).ToList(), tenantId, factoryid);//提前期列表
            var supplierList = GetSupplier(returnlist.Select(p => p.item_id).ToList(), tenantId, factoryid);//供应商列表
            var planList = GetICPlan(returnlist.Select(p => p.item_id).ToList(), tenantId, factoryid);//plan列表
            foreach (var item in returnlist)
            {
                //缺料
                if (item.lack_qty > 0)
                {
                    var itemPO = po_list.FindAll(x => x.icitem_id == item.item_id).OrderBy(v => v.rarrdate).ToList();
                    if (itemPO.Count <= 0 || itemPO.Sum(p => (p.qty - p.esqty)) < item.lack_qty)
                    {
                        //外购生成采购申请单
                        if (item.erp_cls == 3)
                        {
                            //DateTime lastTime = CreateSRMPR(item, tenantId, factoryid, bangid, 2, leadTimeList, supplierList, planList, deliveryDate);
                            //itemlist.Add(new ICItemDateDto { item_id = item.item_id, dateTime = lastTime });
                        }
                        else if (item.erp_cls == 2)
                        {
                            //委外生成委外采购申请单和委外工单
                            //DateTime lastTime = CreateSRMPR(item, tenantId, factoryid, bangid, 1, leadTimeList, supplierList, planList, deliveryDate);
                            //CreateMesOOder(item, tenantId, factoryid, bangid, leadTimeList, supplierList, deliveryDate);
                            //itemlist.Add(new ICItemDateDto { item_id = item.item_id, dateTime = lastTime });
                        }
                    }
                    else
                    {
                        decimal? itemPOQty = 0;//当前物料已抵扣数量
                        for (int i = 0; i < itemPO.Count; i++)
                        {
                            if (itemPOQty + itemPO[i].qty - itemPO[i].esqty >= item.lack_qty)
                            {
                                //在途满足，写占用表
                                itemlist.Add(new ICItemDateDto { item_id = itemPO[i].icitem_id.Value, dateTime = itemPO[i].rarrdate });
                                mo_srm_po_occupy po_Occupy = new mo_srm_po_occupy();
                                po_Occupy.GenerateNewId();
                                po_Occupy.polist_id = itemPO[i].po_id;//采购订单id
                                po_Occupy.polist_row = itemPO[i].polist_row;//采购订单行号
                                po_Occupy.eid = 111;//客户订单行id
                                po_Occupy.bill_no = 111;//客户订单id
                                po_Occupy.type = "在途占用";//类型
                                po_Occupy.entry_id = 1;//行号
                                po_Occupy.qty = item.lack_qty - itemPOQty;//占用量
                                po_Occupy.stime = DateTime.Now;//开始时间
                                po_Occupy.etime = deliveryDate;//结束时间
                                po_Occupy.state = 1;//占用状态
                                po_Occupy.cby = "";//变更人
                                po_Occupy.creason = "";//变更原因
                                po_Occupy.ctime = DateTime.Now;//变更时间
                                po_Occupy.bang_id = bangid;
                                await _srm_po_occupy.InsertOne(po_Occupy);
                                break;
                            }
                            else
                            {
                                //不满足逐步扣减
                                itemPOQty = itemPOQty + itemPO[i].qty - itemPO[i].esqty;
                                mo_srm_po_occupy po_Occupy = new mo_srm_po_occupy();
                                po_Occupy.GenerateNewId();
                                po_Occupy.polist_id = itemPO[i].po_id;//采购订单id
                                po_Occupy.polist_row = itemPO[i].polist_row;//采购订单行号
                                po_Occupy.eid = 111;//客户订单行id
                                po_Occupy.bill_no = 111;//客户订单id
                                po_Occupy.type = "在途占用";//类型
                                po_Occupy.entry_id = 1;//行号
                                po_Occupy.qty = itemPO[i].qty - itemPO[i].esqty;//占用量
                                po_Occupy.stime = DateTime.Now;//开始时间
                                po_Occupy.etime = deliveryDate;//结束时间
                                po_Occupy.state = 1;//占用状态
                                po_Occupy.cby = "";//变更人
                                po_Occupy.creason = "";//变更原因
                                po_Occupy.ctime = DateTime.Now;//变更时间
                                po_Occupy.bang_id = bangid;
                                await _srm_po_occupy.InsertOne(po_Occupy);
                            }
                        }
                    }
                }
            }
            return itemlist;
        }

        ///// <summary>
        ///// 生成委外工单
        ///// </summary>
        ///// <param name="returnlist"></param>
        ///// <param name="factoryid"></param>
        //private DateTime CreateMesOOder(BomChildExamineDto returnlist, long tenantId, long factoryid, long bangId, List<ICItemLeadTimeDto> iCItemLeadTimes, List<ic_item_pur> supplierList, DateTime deliveryDate)
        //{
        //    mes_oorder oOrder = new mes_oorder();
        //    oOrder.GenerateNewId();
        //    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_stime = DateTime.Now;//计划开工日期
        //    oOrder.ooentry_etime = DateTime.Now;//计划完工日期
        //    oOrder.product_code = "产品代码";//产品代码
        //    oOrder.ffms_number = "1000";//fms旧料号
        //    oOrder.product_name = "test";//产品名称
        //    oOrder.specification_model = returnlist.model;//规格型号
        //    oOrder.bom_number = "";//bom编码
        //    oOrder.unit = returnlist.unit;//单位
        //    oOrder.morder_progress = "";//工单进度
        //    oOrder.morder_production_number = returnlist.lack_qty;//工单生产数量(计划数量)
        //    oOrder.need_number = returnlist.lack_qty;//需求数量
        //    oOrder.remaining_number = returnlist.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.tenant_id = tenantId;
        //    oOrder.factory_id = factoryid;
        //    oOrder.bang_id = bangId;
        //    _mes_oorder.InsertOne(oOrder);
        //    return DateTime.Now;
        //}

        /// <summary>
        /// 生成委外工单
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="factoryid"></param>
        private mo_mes_oorder CreateMesOOder(BomChildExamineDto returnlist, long tenantId, long factoryid, long bangId, List<ICItemLeadTimeDto> iCItemLeadTimes, List<srm_purchase> supplierList, DateTime deliveryDate)
        {
            mo_mes_oorder oOrder = new mo_mes_oorder();
            oOrder.GenerateNewId();
            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_stime = DateTime.Now;//计划开工日期
            oOrder.ooentry_etime = DateTime.Now;//计划完工日期
            oOrder.product_code = "产品代码";//产品代码
            oOrder.ffms_number = "1000";//fms旧料号
            oOrder.product_name = "test";//产品名称
            oOrder.specification_model = returnlist.model;//规格型号
            oOrder.bom_number = returnlist.bom_number;//bom编码
            oOrder.unit = returnlist.unit;//单位
            oOrder.morder_progress = "";//工单进度
            oOrder.morder_production_number = returnlist.lack_qty;//工单生产数量(计划数量)
            oOrder.need_number = returnlist.lack_qty;//需求数量
            oOrder.remaining_number = returnlist.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.tenant_id = tenantId;
            oOrder.factory_id = factoryid;
            oOrder.bang_id = bangId;
            return oOrder;
            //_mes_oorder.InsertOne(oOrder);
        }


        ///// <summary>
        ///// 生成采购申请单,颗粒度是一个物料一个单，没必要弄列表
        ///// </summary>
        ///// <param name="returnlist"></param>
        ///// <param name="factoryid"></param>
        ///// <param name="orderType">2委外采购申请单，3采购申请单</param>
        //private DateTime CreateSRMPR(BomChildExamineDto returnlist, long tenantId, long factoryid, long bangId, int orderType, List<ICItemLeadTimeDto> iCItemLeadTimes, List<ic_item_pur> supplierList, List<ic_plan> planList, DateTime deliveryDate)
        //{
        //    var leadTime = iCItemLeadTimes.Find(x => x.item_id == returnlist.item_id);
        //    var supplier = supplierList.Find(x => x.icitem_id == returnlist.item_id);//默认取第一个供应商
        //    var plan = planList.Find(x => x.icitem_id == returnlist.item_id);
        //    if (leadTime == null || supplier == null || plan == null)
        //    {
        //        throw new NotImplementedException("未找到物料ic_factory_details或ic_item_pur或ic_plan信息！");
        //    }
        //    srm_pr_main srm_Pr = new srm_pr_main();
        //    srm_Pr.GenerateNewId();
        //    srm_Pr.pr_billno = getOrderNum("PR");//pr单号
        //    srm_Pr.pr_mono = "";//关联工单号
        //    srm_Pr.entity_id = 1;//工单行号
        //    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.purcher;//采购员
        //    srm_Pr.pr_purchaser_num = "";//采购员工号（采购信息表）
        //    srm_Pr.pr_rqty = returnlist.lack_qty;//需求数量
        //    srm_Pr.pr_aqty = returnlist.lack_qty;//申请数量
        //    srm_Pr.pr_sqty = returnlist.lack_qty;//建议数量
        //    srm_Pr.icitem_id = returnlist.item_id;//物料id
        //    srm_Pr.icitem_name = returnlist.item_name;//物料名称
        //    srm_Pr.pr_order_type = 1;//单据类型
        //    srm_Pr.pr_ssend_date = deliveryDate.AddDays((double)leadTime.order_leadtime * -1);//系统建议下单日期
        //    srm_Pr.pr_sarrive_date = deliveryDate.AddDays((double)leadTime.transportation_leadtime * -1);//系统建议到达日期（建议到货日期）
        //    srm_Pr.pr_psend_date = deliveryDate.AddDays((double)leadTime.order_leadtime * -1);//计划下单日期
        //    srm_Pr.pr_parrive_date = deliveryDate.AddDays((double)leadTime.transportation_leadtime * -1);//计划到达日期
        //    srm_Pr.pr_psend_date = deliveryDate.AddDays((double)leadTime.order_leadtime * -1);//计划下单日期
        //    srm_Pr.pr_sysprice = returnlist.lack_qty * supplier.netpurchase_price * (1 + supplier.taxrate);//系统价格（含税）
        //    srm_Pr.pr_orderprice = returnlist.lack_qty * supplier.netpurchase_price * (1 + supplier.taxrate);//订单价格（含税）
        //    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;//币种
        //    srm_Pr.secInv_ratio = plan.secinv_ratio;//安全库存触发采购比例
        //    srm_Pr.tenant_id = tenantId;
        //    srm_Pr.factory_id = factoryid;
        //    srm_Pr.bang_id = bangId;
        //    _srm_pr_main.InsertOne(srm_Pr);
        //    decimal? totalLeadTime = leadTime.transportation_leadtime + leadTime.stock_leadtime + leadTime.production_leadtime + leadTime.order_leadtime;
        //    return deliveryDate.AddDays((double)totalLeadTime * -1);//减去提前期
        //}

        /// <summary>
        /// 生成采购申请单,颗粒度是一个物料一个单，没必要弄列表
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="factoryid"></param>
        /// <param name="orderType">2委外采购申请单，3采购申请单</param>
        private SRMPRDto CreateSRMPR(BomChildExamineDto returnlist, long tenantId, long factoryid, long bangId, int orderType, List<ICItemLeadTimeDto> iCItemLeadTimes, List<srm_purchase> supplierList, List<ic_plan> planList, DateTime deliveryDate)
        {
            SRMPRDto sRMPR = new SRMPRDto();
            mo_srm_pr_main srm_Pr = new mo_srm_pr_main();
            var leadTime = iCItemLeadTimes.Find(x => x.item_id == returnlist.item_id);
            var supplier = supplierList.Find(x => x.icitem_id == returnlist.item_id);//默认取第一个供应商
            var plan = planList.Find(x => x.icitem_id == returnlist.item_id);
            if (leadTime == null || supplier == null || plan == null)
            {
                sRMPR.srm_Pr_Main = null;
                sRMPR.lastStartTmie = deliveryDate.AddDays(7 * -1);//减去提前期
                return sRMPR;
                //throw new NotImplementedException("未找到物料ic_factory_details或ic_item_pur或ic_plan信息！");
            }

            srm_Pr.GenerateNewId();
            srm_Pr.pr_billno = getOrderNum("PR");//pr单号
            srm_Pr.pr_mono = "";//关联工单号
            srm_Pr.entity_id = 1;//工单行号
            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.purcher;//采购员
            srm_Pr.pr_purchaser_num = "";//采购员工号（采购信息表）
            srm_Pr.pr_rqty = returnlist.lack_qty;//需求数量
            srm_Pr.pr_aqty = returnlist.lack_qty;//申请数量
            srm_Pr.pr_sqty = returnlist.lack_qty;//建议数量
            srm_Pr.icitem_id = returnlist.item_id;//物料id
            srm_Pr.icitem_name = returnlist.item_name;//物料名称
            srm_Pr.pr_order_type = 1;//单据类型
            srm_Pr.pr_ssend_date = deliveryDate.AddDays((double)leadTime.order_leadtime * -1);//系统建议下单日期
            srm_Pr.pr_sarrive_date = deliveryDate.AddDays((double)leadTime.transportation_leadtime * -1);//系统建议到达日期（建议到货日期）
            srm_Pr.pr_psend_date = deliveryDate.AddDays((double)leadTime.order_leadtime * -1);//计划下单日期
            srm_Pr.pr_parrive_date = deliveryDate.AddDays((double)leadTime.transportation_leadtime * -1);//计划到达日期
            srm_Pr.pr_psend_date = deliveryDate.AddDays((double)leadTime.order_leadtime * -1);//计划下单日期
            srm_Pr.pr_sysprice = returnlist.lack_qty * supplier.netpurchase_price * (1 + supplier.taxrate);//系统价格（含税）
            srm_Pr.pr_orderprice = returnlist.lack_qty * supplier.netpurchase_price * (1 + supplier.taxrate);//订单价格（含税）
            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;//币种
            srm_Pr.secInv_ratio = plan.secinv_ratio;//安全库存触发采购比例
            srm_Pr.tenant_id = tenantId;
            srm_Pr.factory_id = factoryid;
            srm_Pr.bang_id = bangId;
            //_srm_pr_main.InsertOne(srm_Pr);
            decimal? totalLeadTime = leadTime.transportation_leadtime + leadTime.stock_leadtime + leadTime.production_leadtime + leadTime.order_leadtime;

            sRMPR.srm_Pr_Main.Add(srm_Pr);
            sRMPR.lastStartTmie = deliveryDate.AddDays((double)totalLeadTime * -1);//减去提前期
            return sRMPR;
        }

        // 生成订单编号 字母+年月日+8位随机数+时间戳
        private 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="input"></param>
        /// <returns></returns>
        public async Task<string> OrderResourceCheck(OrderCheckDto input)
        {
            var result = await OrderKittingCheck(input);
            OrderResourceViewDto rtn = DataPackage(result);
            rtn.DayBulletinBoardList = rtn.DayBulletinBoardList.OrderByDescending(d => d.day).ToList();
            //保存检查结果
            SaveExamineResult(rtn.KittingCheckResultList, rtn.DayBulletinBoardList, 1);
            return JsonConvert.SerializeObject(rtn);
        }

        /// <summary>
        /// 工单齐套检查/替代料齐套检查结果保存
        /// </summary>
        /// <param name="KittingCheckResultList"></param>
        /// <param name="DayBulletinBoardList"></param>
        public async void SaveExamineResult(List<OrderResourceDto> KittingCheckResultList, List<DayBulletinBoard> DayBulletinBoardList,int type)
        {
            //检查结果写入数据库
            List<b_order_examine_result> examineList = new List<b_order_examine_result>();
            List<b_order_detail> orderDetails = new List<b_order_detail>();
            List<b_day_bulletin_board> daybulletinboards = new List<b_day_bulletin_board>();

            foreach (var ex in KittingCheckResultList)
            {
                var examine = ObjectMapper.Map<OrderResourceDto, b_order_examine_result>(ex);
                examine.GenerateNewId(help.NextId());
                examine.type = type;
                examine.create_time = DateTime.Now;
                examine.tenant_id = param.tenantId;
                examine.factory_id = param.factoryId;
                examine.create_time = DateTime.Now;
                examineList.Add(examine);

                ex.order_item_list.ForEach(s => {
                    var detail = ObjectMapper.Map<OrderItemDto, b_order_detail>(s);
                    detail.GenerateNewId(help.NextId());
                    detail.order_examine_id = examine.Id;
                    detail.tenant_id = param.tenantId;
                    detail.factory_id = param.factoryId;
                    detail.create_time = DateTime.Now;
                    orderDetails.Add(detail);
                });
            }

            foreach (var item in DayBulletinBoardList)
            {
                var detail = ObjectMapper.Map<DayBulletinBoard, b_day_bulletin_board>(item);
                detail.GenerateNewId(help.NextId());
                detail.type = type;
                detail.create_time = DateTime.Now;
                detail.tenant_id = param.tenantId;
                detail.factory_id = param.factoryId;
                daybulletinboards.Add(detail);
            }
            if (examineList.Any())
            {
                _businessBangDbContext.BulkInsert(examineList);
            }
            if (daybulletinboards.Any())
            {
                _businessBangDbContext.BulkInsert(daybulletinboards);
            }
            if (orderDetails.Any())
            {
                _businessBangDbContext.BulkInsert(orderDetails);
            }
            
        }

        /// <summary>
        /// 替代关系检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> SubstituteResourceCheck(OrderCheckDto input)
        {
            var result = await OrderKittingCheck(input);
            OrderResourceViewDto rtn = DataPackage(result, true);
            rtn.DayBulletinBoardList = rtn.DayBulletinBoardList.OrderByDescending(d => d.day).ToList();
            //保存检查结果 替代关系不计算每日物料情况
            SaveExamineResult(rtn.KittingCheckResultList, new List<DayBulletinBoard>(), 2);
            //SaveExamineResult(rtn.KittingCheckResultList, rtn.DayBulletinBoardList, 2);
            return JsonConvert.SerializeObject(rtn);
        }

        /// <summary>
        /// 检查结果组装
        /// </summary>
        /// <param name="result"></param>
        /// <param name="flag"></param>
        /// <returns></returns>
        public OrderResourceViewDto DataPackage(PschedDto result,bool flag =false)
        {
            OrderResourceViewDto rtn = new OrderResourceViewDto();
            rtn.KittingCheckResultList = new List<OrderResourceDto>();
            rtn.DayBulletinBoardList = new List<DayBulletinBoard>();
            result.examines.ForEach(examine =>
            {
                OrderResourceDto dto = new OrderResourceDto();
                dto.orderId = examine.morder_id.GetValueOrDefault();
                dto.order_no = examine.morder_no;
                dto.time = examine.order_statr_time.GetValueOrDefault();
                dto.ketting_time = examine.kitting_times;
                dto.need_qty = examine.need_qty;
                dto.bom_number = examine.bom_number;
                dto.order_item_list = new List<OrderItemDto>();
                var list = examine.BomChildExamineList;
                if (flag)
                {
                    list = list.Where(s => s.type == 1 || s.haveicsubs == 1).ToList();
                }
                list.ForEach(subitem =>
                {
                    var cdto = ObjectMapper.Map<BomChildExamineDto, OrderItemDto>(subitem);
                    /*OrderItemDto cdto = new OrderItemDto();
                    cdto.fid = subitem.fid;
                    cdto.parent_id = subitem.parent_id;
                    cdto.bom_number = subitem.bom_number;
                    cdto.item_id = subitem.item_id;
                    cdto.item_name = subitem.item_name;
                    cdto.item_number = subitem.item_number;
                    cdto.num = subitem.num;
                    cdto.num_order = subitem.num_order;
                    cdto.qty = subitem.qty;
                    cdto.self_lack_qty = subitem.self_lack_qty;
                    cdto.sqty = subitem.sqty;
                    cdto.use_qty = subitem.use_qty;
                    cdto.mo_qty = subitem.mo_qty;
                    cdto.mo_occupy_list = subitem.mo_occupy_list;
                    cdto.make_qty = subitem.make_qty;
                    cdto.make_list = subitem.make_list;
                    cdto.purchase_qty = subitem.purchase_qty;
                    cdto.purchase_list = subitem.purchase_list;
                    cdto.purchase_occupy_qty = subitem.purchase_occupy_qty;
                    cdto.purchase_occupy_list = subitem.purchase_occupy_list;
                    cdto.subcontracting_qty = subitem.subcontracting_qty;
                    cdto.subcontracting_list = subitem.subcontracting_list;
                    cdto.kitting_time = subitem.kitting_time;
                    cdto.substitute_code = subitem.substitute_code;
                    cdto.substitute_strategy = subitem.substitute_strategy;
                    cdto.substitute_mode = subitem.substitute_mode;
                    cdto.is_use = subitem.is_use;*/
                    dto.order_item_list.Add(cdto);
                    string day = dto.time.ToString("yyyy-MM-dd HH:mm");
                    if (subitem.is_use && subitem.level != 1)
                    {
                        //每日每物料使用情况
                        DayBulletinBoard dbb = rtn.DayBulletinBoardList.Find(s => s.day == day && s.item_number == cdto.item_number);
                        if (dbb == null)
                        {
                            dbb = new DayBulletinBoard();
                            dbb.day = day;
                            dbb.item_name = cdto.item_name;
                            dbb.item_number = cdto.item_number;
                            rtn.DayBulletinBoardList.Add(dbb);
                        }
                        dbb.self_lack_qty += subitem.lack_qty;
                        dbb.use_qty += subitem.use_qty;
                        dbb.make_qty += cdto.make_qty;
                        dbb.mo_qty += subitem.mo_qty;
                        dbb.purchase_occupy_qty += subitem.purchase_occupy_qty;
                    }
                });
                rtn.KittingCheckResultList.Add(dto);
            });
            return rtn;
        }

        /// <summary>
        /// 工单检查物料齐套
        /// </summary>
        /// <param name="input"></param>
        public async Task<PschedDto> OrderKittingCheck(OrderCheckDto input)
        {
            //资源检查结果
            PschedDto rtn = new PschedDto();
            //资源检查明细list
            List<ExamineResult> examines = new List<ExamineResult>();

            //资源检查入参全局变量赋值
            param.tenantId = input.tenantId;
            param.factoryId = input.factoryId;
            param.checkflag = false;

            //生成当前计算bangid
            long bangid = help.NextId();

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

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

            List <mes_morder> mo_Mes_Morders = _mysql_mes_morder.GetListAsync(x => x.start_time > DateTime
            .Now.Date.AddDays(1) && x.start_time < DateTime
            .Now.Date.AddDays(input.Day) && x.morder_state != MorderEnum.Accomplish_state && !x.IsDeleted && x.tenant_id == param.tenantId).Result;

            List<mes_moentry> mo_Mes_Moentries = _mysql_mes_moentry.GetListAsync(x => mo_Mes_Morders.Select(s => s.Id).Contains(x.moentry_moid.Value)).Result;

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

            //删除同步Mysql后旧数据
            await DeleteMySqlOldData(sentrys);
            //数据库快照-同步mysql库数据到mongoDB中
            await DbSnapShot(input.tenantId, input.factoryId, bangid);

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

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

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

            DataInitialization(boms, bangid, null, icitemlist, stocklist, pretreatments);

            foreach (var item in mo_Mes_Morders)
            {
                var moentry = mo_Mes_Moentries.Find(s => s.moentry_moid == item.Id);
                if (moentry == null)
                {
                    continue;
                }
                var sentry = sentrys.Find(s => s.Id == moentry.soentry_id);

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

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

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

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

                if (sentry != null)
                {
                    dtl.sentry_id = sentry.Id;
                    getBomList.ForEach(s => s.sentry_id = item.Id);
                }

                //库存初始化
                _CalcBomViewAppService.BomStock(getBomList, stocklist, bangid);
                //计算
                _CalcBomViewAppService.CalcView(getBomList, bangid, item.need_number.GetValueOrDefault(), item.start_time, sklist, sentry, icitemlist);

                //TODO:最晚开始时间
                var curFacDtl = leadTimeList.FirstOrDefault(p => p.item_id == childBom.icitem_id);
                //物料齐套时间
                dtl.kitting_times = getBomList.Where(p => p.is_use && p.kitting_time != null).OrderByDescending(m => m.kitting_time).First().kitting_time.GetValueOrDefault();
                //替代关系展开list
                dtl.BomChildExamineList = getBomList;
                //添加订单行开工信息
                examines.Add(dtl);
            }
            rtn.examines = examines;
            //清空快照数据
            await ClearSnapShot(bangid);
            return rtn;
        }

        /// <summary>
        /// 物料数据计算前准备
        /// </summary>
        /// <param name="boms"></param>
        /// <param name="bangid"></param>
        /// <param name="sorder"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        /// <param name="icitemlist"></param>
        /// <param name="sublist"></param>
        /// <param name="suballlist"></param>
        /// <param name="subdtllist"></param>
        /// <param name="stocklist"></param>
        /// <param name="sklist"></param>
        /// <exception cref="NotImplementedException"></exception>
        public void DataInitialization(List<mo_ic_bom> boms,long bangid, crm_seorder sorder, List<mo_ic_item> icitemlist, List<mo_ic_item_stock> stocklist,List<b_bom_pretreatment> pretreatments)
        {
            List<long> itemIds = pretreatments.Select(p => p.item_id.GetValueOrDefault()).ToList();
            icitemlist.AddRange(_ic_item.GetManyByCondition(p => itemIds.Contains(p.mysql_id) && !p.IsDeleted).Result);
            #region 1、数据准备
            //1.1、获取工艺路径数据
            List<mo_ic_bom> bomlist = _ic_bom.GetManyByCondition(p => itemIds.Contains(p.icitem_id) && p.use_status == 1 && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.ToList();
            List<mo_mes_technique> techs = GetMesTechniques(bomlist);
            if (techs.Count == 0)
            {
                //throw new NotImplementedException("请先配置工艺路径！");
            }

            //1.2、获取工艺路径关联工序数据
            List<mo_mes_tech_process> tech_Processes = _mes_tech_process.GetManyByCondition(p => techs.Select(m => m.mysql_id).Contains(p.tech_id) && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result;
            if (tech_Processes.Count == 0)
            {
                //throw new NotImplementedException("请先配置工序！");
            }

            //1.3、获取当前工艺路径下的工序数据
            List<long> procIds = tech_Processes.Select(m => m.proc_id).ToList();
            List<mo_mes_process> process =  _mes_process.GetManyByCondition(p => procIds.Contains(p.mysql_id) && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result;

            //1.3、获取工艺工序关联工位信息
            List<long> techProcIds = tech_Processes.Select(m => m.mysql_id).ToList();
            List<mo_mes_tech_proc_workshop> tech_Proc_Workshops =  _mes_tech_proc_workshop.GetManyByCondition(p => techProcIds.Contains(p.tech_proc_id) && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result;
            //主工单
            List<mo_mes_morder> mo_Mes_Morders = _mes_morder.GetManyByCondition(x => boms.Select(p => p.bom_number).Contains(x.bom_number) && (x.morder_state != MorderEnum.Accomplish_state || x.morder_state != MorderEnum.Close_state
          && x.morder_icitem_type != MorderEnum.XgwyMorder) && !x.IsDeleted && x.tenant_id == param.tenantId && x.bang_id == bangid).Result;
            //工单占用表
            List<mo_mes_mooccupy> mes_mooccupyList = _mes_mooccupy.GetManyByCondition(x => x.moo_state == 1 && !x.IsDeleted && x.tenant_id == param.tenantId
          && boms.Select(p => p.item_number).Contains(x.fitem_number) && x.bang_id == bangid).Result;

            //物料采购订单明细
            var poDetailList = _srm_po_list.GetManyByCondition(x => boms.Select(p => p.icitem_id).ToList().Contains(x.icitem_id.Value) && x.state == 1 && x.rstate == 1 && !x.IsDeleted).Result;
            //采购订单占用数据
            var poOccupys = _srm_po_occupy.GetManyByCondition(x => poDetailList.Select(p => p.id).ToList().Contains(x.polist_id) && !x.IsDeleted).Result;
            #endregion

            //物料库存
            stocklist.AddRange(_ic_item_stock.GetManyByCondition(p => p.factory_id == param.factoryId && p.bang_id == bangid && itemIds.Contains(p.icitem_id)).Result);

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

            _morderAppService.param = param;
            _purchaseOrderAppService.param = param;
            _CalcBomViewAppService.param = param;
            _CalcBomViewAppService.planList = planList;
            _CalcBomViewAppService.leadTimeList = leadTimeList;
            _CalcBomViewAppService.supplierList = supplierList;
            //资源检查添加工艺路径数据
            _CalcBomViewAppService.techs = techs;//工艺路径
            _CalcBomViewAppService.tech_Processes = tech_Processes;//工艺关联工序
            _CalcBomViewAppService.process = process;//工序
            _CalcBomViewAppService.tech_Proc_Workshops = tech_Proc_Workshops;//工艺工序关联工位
            _CalcBomViewAppService.mordersList = mo_Mes_Morders;//工单
            _CalcBomViewAppService.mooccupyAllList = mes_mooccupyList;//工单占用表
            _CalcBomViewAppService.seorder = sorder;//销售订单
            _CalcBomViewAppService.srm_Po_Lists = poDetailList; //采购明细
            _CalcBomViewAppService.srm_Po_Occupies = poOccupys; //采购占用表
        }

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

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

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

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

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

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

        /// <summary>
        /// 自动生成BOM预处理清单
        /// </summary>
        public void AutoCreateBomBill(List<mo_ic_bom> ic_Boms=null)
        {
            if (ic_Boms == null)
            {
                ic_Boms = _ic_bom.Find(p => p.factory_id == 10101 && p.tenant_id == 101 && !p.IsDeleted).Result.ToList();
            }

            var pretreatment = _mysql_b_bom_pretreatment.GetListAsync(s => ic_Boms.Select(c => c.mysql_id).ToList().Contains(s.sourceid)).Result;

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

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

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

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

        /// <summary>
        /// BOM清单批量预处理
        /// </summary>
        public void AutoCreateBomBillInterface()
        {
            AutoCreateBomBill();
        }
    }
}