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;
using MongoDB.Bson.Serialization.Attributes;
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics;
using Volo.Abp.Uow;
using Spire.Pdf.Exporting.XPS.Schema;
using Business.PriorityManagement;
using Newtonsoft.Json.Linq;
using Business.Dto;
using NetTopologySuite.Simplify;

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_srm_supplier> _srm_supplier;
        private IRepository<srm_supplier, long> _mysql_srm_supplier;

        /// <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 ISqlRepository<RoutingOpDetail> _routingOpDetail;

        /// <summary>
        /// 生产线明细
        /// </summary>
        private readonly ISqlRepository<ProdLineDetail> _prodLineDetail;

        /// <summary>
        /// 排产记录表
        /// </summary>
        private readonly ISqlRepository<PeriodSequenceDet> _periodSequenceDet;

        /// <summary>
        /// 工作日历
        /// </summary>
        private readonly ISqlRepository<ShopCalendarWorkCtr> _shopCalendarWorkCtr;

        /// <summary>
        /// 休息时间段
        /// </summary>
        private readonly ISqlRepository<QualityLineWorkDetail> _qualityLineWorkDetail;

        /// <summary>
        /// 节假日
        /// </summary>
        private readonly ISqlRepository<HolidayMaster> _holidayMaster;

        /// <summary>
        /// 标准BOM表
        /// </summary>
        private readonly ISqlRepository<ProductStructureMaster> _productStructureMaster;

        /// <summary>
        /// 工单工序表
        /// </summary>
        private ISqlRepository<WorkOrdRouting> _workOrdRouting;

        /// <summary>
        /// 工单主表
        /// </summary>
        private ISqlRepository<WorkOrdMaster> _workOrdMaster;

        /// <summary>
        /// 工单物料明细
        /// </summary>
        private ISqlRepository<WorkOrdDetail> _workOrdDetail;

        private readonly ISqlRepository<rf_serialnumber> _rf_serialnumber;
        private readonly ISqlRepository<LocationDetail> _locationDetail;
        /// <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;
        /// <summary>
        /// 生产线维护表
        /// </summary>
        private ISqlRepository<LineMaster> _lineMaster;
        private ISqlRepository<ItemMaster> _itemMaster;
        private ISqlRepository<NbrMaster> _nbrMaster;
        private ISqlRepository<NbrDetail> _nbrDetail;
        private ISqlRepository<ItemPackMaster> _itemPackMaster;
        /// <summary>
        /// 生产排产
        /// </summary>
        private readonly ProductionScheduleAppService _productionScheduleAppService;

        /// <summary>
        /// 优先级
        /// </summary>
        private readonly PriorityAppService _priorityAppService;

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

        /// <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>();
        #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,
            IMongoDB<mo_srm_supplier> srm_supplier,
            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,
            IRepository<srm_supplier, long> mysql_srm_supplier,
            ISqlRepository<TagMaster> tagMasterRepository,
            ISqlRepository<PeriodSequenceDet> periodSequenceDet,
            ISqlRepository<LineMaster> lineMaster,
            ISqlRepository<ItemMaster> itemMaster,
            PretreatmentAppService pretreatmentAppService,
            CalcBomViewAppService calcbomviewAppService,
            PurchaseOrderAppService purchaseOrderAppService,
            ICurrentTenant currentTenant,
            MorderAppService morderAppService,
            BusinessBangDbContext businessBangDbContext,
            BusinessDbContext businessDbContext,
            ProductionScheduleAppService productionScheduleAppService,
            ISqlRepository<RoutingOpDetail> routingOpDetail,
            ISqlRepository<ProductStructureMaster> productStructureMaster,
            ISqlRepository<WorkOrdRouting> workOrdRouting,
            ISqlRepository<WorkOrdMaster> workOrdMaster,
            ISqlRepository<WorkOrdDetail> workOrdDetail,
            ISqlRepository<NbrMaster> nbrMaster,
            ISqlRepository<NbrDetail> nbrDetail,
            PriorityAppService priorityAppService,
            ISqlRepository<ProdLineDetail> prodLineDetail,
            ISqlRepository<ShopCalendarWorkCtr> shopCalendarWorkCtr,
            ISqlRepository<QualityLineWorkDetail> qualityLineWorkDetail,
            ISqlRepository<HolidayMaster> holidayMaster,
            ProductExamineAppService productExamineAppService,
            ISqlRepository<rf_serialnumber> rf_serialnumber,
            ISqlRepository<LocationDetail> locationDetail,
            ISqlRepository<ItemPackMaster> itemPackMaster
            )
        {
            _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;
            _srm_supplier = srm_supplier;
            _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;
            _mysql_srm_supplier = mysql_srm_supplier;
            _tagMasterRepository = tagMasterRepository;
            _periodSequenceDet = periodSequenceDet;
            _pretreatmentAppService = pretreatmentAppService;
            _CalcBomViewAppService = calcbomviewAppService;
            _purchaseOrderAppService = purchaseOrderAppService;
            _currentTenant = currentTenant;
            _morderAppService = morderAppService;
            _businessBangDbContext = businessBangDbContext;
            _businessDbContext = businessDbContext;
            _productionScheduleAppService = productionScheduleAppService;
            _routingOpDetail = routingOpDetail;
            _productStructureMaster = productStructureMaster;
            _workOrdRouting = workOrdRouting;
            _workOrdMaster=workOrdMaster;
            _workOrdDetail=workOrdDetail;
            _lineMaster = lineMaster;
            _itemMaster = itemMaster;
            _nbrMaster = nbrMaster;
            _nbrDetail = nbrDetail;
            _priorityAppService= priorityAppService;
            _rf_serialnumber = rf_serialnumber;
            _prodLineDetail = prodLineDetail;
            _shopCalendarWorkCtr = shopCalendarWorkCtr;
            _qualityLineWorkDetail = qualityLineWorkDetail;
            _holidayMaster = holidayMaster;
            _productExamineAppService= productExamineAppService;
            _locationDetail = locationDetail;
            _itemPackMaster = itemPackMaster;
        }
        #endregion



        /// <summary>
        /// 资源检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<string> ReceiveResult(ResourceCheckInputDto input)
        {
            //资源检查入参全局变量赋值
            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;

            //生成当前计算bangid
            long bangid = help.NextId();
            //获取订单数据
            List<crm_seorder> sorders = _mysql_crm_seorder.GetListAsync(p => p.tenant_id == input.tenantId && p.factory_id == input.factoryId && input.sorderId.Contains(p.Id) && !p.IsDeleted).Result;
            if (!sorders.Any())
            {
                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 && input.sorderId.Contains(p.seorder_id.GetValueOrDefault()) && !p.IsDeleted);

            //处理销售订单优先级
            sorders = _priorityAppService.CalcOrderPriority(sorders, sentrys);
            AsyncItemStockFromWMS(sentrys);
            //处理订单行优先级
            sentrys = _priorityAppService.CalcOrderEntryPriority(sorders, sentrys);

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


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

            //通过订单行的产品代码获取物料BOM数据
            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();
            //物料信息
            List<mo_ic_item> icitemlist = new List<mo_ic_item>();
            //物料库存表
            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;
            }
            //记录订单行的物料齐套时间
            List<KittingTimeDto> kittingTimes = new List<KittingTimeDto>();
            DataInitialization(boms, bangid, icitemlist, stocklist, pretreatments);
            foreach (var sorder in sorders)
            {
                param.sorderId = sorder.Id;
                param.tenantId = input.tenantId;
                param.factoryId = input.factoryId;
                param.checkflag = true;
                _morderAppService.param = param;
                _purchaseOrderAppService.param = param;
                _CalcBomViewAppService.param = param;
                _CalcBomViewAppService.seorder = sorder;//销售订单
                var orderSentrys = sentrys.Where(s => s.seorder_id == sorder.Id).ToList();
                foreach (var item in orderSentrys)
                {
                    //获取销售订单“是否加急”字段
                    int urgent = sorder.urgent;

                    //工单资源检查信息
                    dtl = new ExamineResult();
                    dtl.sorderid = sorder.Id;
                    dtl.bill_no = sorder.bill_no;
                    dtl.sentry_id = item.Id;
                    dtl.entry_seq = item.entry_seq;
                    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, urgent, 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);
                    item.progress = "2";
                    //替代关系展开list
                    dtl.BomChildExamineList = getBomList;
                    //添加订单行开工信息
                    examines.Add(dtl);

                    //记录订单行的建议交期
                    KittingTimeDto dto = new KittingTimeDto();
                    dto.sentry_id = item.Id;
                    dto.ItemNum = item.item_number;
                    dto.LackQty = getBomList.First(p => p.level == 1).lack_qty;
                    dto.kitting_time = dtl.kitting_times;
                    kittingTimes.Add(dto);
                }
            }
            //计算订单行的建议交期(产能/物料)
            CalcSuggestDate(sentrys, kittingTimes);

            await _mysql_crm_seorderentry.UpdateManyAsync(sentrys);

            //批量保存 后期考虑子工单
            if (_CalcBomViewAppService.mordersInsertList.Any())
            {
                _CalcBomViewAppService.mordersInsertList.ForEach(s => { s.tenant_id = param.tenantId; s.factory_id = param.factoryId; });
                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;
                //同步工单
                CreateWorkOrdDates(mesorders);
            }
            if (_CalcBomViewAppService.mooccupyAllInsertList.Any())
            {
                _CalcBomViewAppService.mooccupyAllInsertList.ForEach(s => { s.tenant_id = param.tenantId; s.factory_id = param.factoryId; });
                await _mes_mooccupy.InsertMany(_CalcBomViewAppService.mooccupyAllInsertList);
                rtn.mooccupyAllList = _CalcBomViewAppService.mooccupyAllInsertList;
            }
            if (_CalcBomViewAppService.moentriesInsertList.Any())
            {
                _CalcBomViewAppService.moentriesInsertList.ForEach(s => { s.tenant_id = param.tenantId; s.factory_id = param.factoryId; });
                await _mes_moentry.InsertMany(_CalcBomViewAppService.moentriesInsertList);
                var mesmoentrys = ObjectMapper.Map<List<mo_mes_moentry>, List<mes_moentry>>(_CalcBomViewAppService.moentriesInsertList);
                _businessDbContext.BulkInsert(mesmoentrys);
            }
            if (_CalcBomViewAppService.orderList.Any())
            {
                _CalcBomViewAppService.orderList.ForEach(s => { s.tenant_id = param.tenantId; s.factory_id = param.factoryId; });
                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(); s.tenant_id = param.tenantId; s.factory_id = param.factoryId; });
                await _ic_item_stockoccupy.InsertMany(sklist);
            }
            if (_CalcBomViewAppService.srm_Po_OccupiesInsert.Any())
            {
                _CalcBomViewAppService.srm_Po_OccupiesInsert.ForEach(s => { s.tenant_id = param.tenantId; s.factory_id = param.factoryId; });
                await _srm_po_occupy.InsertMany(_CalcBomViewAppService.srm_Po_OccupiesInsert);
            }
            if (_CalcBomViewAppService.SRMPRDtoList.Any())
            {
                List<List<mo_srm_pr_main>> prlist = _CalcBomViewAppService.SRMPRDtoList.Where(f => f.srm_Pr_Main != null).Select(s => s.srm_Pr_Main).ToList();
                List<mo_srm_pr_main> list = new List<mo_srm_pr_main>();
                foreach (var pr in prlist)
                {
                    foreach (var item in pr)
                    {
                        list.Add(item);
                    }
                }
                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);
                    AutoCreatePOFromPR(list, bangid, input);
                }
                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();
                if (_CalcBomViewAppService.mordersInsertList.Any())
                {
                    b_ex.morder_id = _CalcBomViewAppService.mordersInsertList[0].mysql_id;
                    b_ex.morder_no = _CalcBomViewAppService.mordersInsertList[0].morder_no;
                }
                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 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,
                    put_integer=x.put_integer,
                    minpackqty=x.minpackqty,
                    ordissu_days=x.ordissu_days
                }).AsQueryable<ICItemLeadTimeDto>().ToList();
        }

        //根据物料id获取物料供应商
        private List<mo_srm_purchase> GetSupplier(List<long> icItemIds, long 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="orderTime1">基准订单时间</param>
        /// <param name="orderTime2">目标订单时间</param>
        /// <returns></returns>
        private bool IsSameWeek(DateTime orderTime1, DateTime orderTime2)
        {
            int week = (int)orderTime1.DayOfWeek;
            bool isSameWeek = false;
            DateTime dateTime = orderTime1;
            switch (week)
            {
                case 0:
                    //星期天
                    dateTime = dateTime.AddDays(0);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
                case 1:
                    //星期一
                    dateTime = dateTime.AddDays(4);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
                case 2:
                    //星期二
                    dateTime = dateTime.AddDays(3);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
                case 3:
                    //星期三
                    dateTime = dateTime.AddDays(2);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
                case 4:
                    //星期四
                    dateTime = dateTime.AddDays(1);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
                case 5:
                    //星期五
                    dateTime = dateTime.AddDays(0);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
                case 6:
                    //星期六
                    dateTime = dateTime.AddDays(0);
                    dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59);
                    isSameWeek = orderTime2 < dateTime;
                    break;
            }
            return isSameWeek;
        }
        private void AutoCreatePOFromPR(List<mo_srm_pr_main> list, long bangid, ResourceCheckInputDto input)
        {
            var zcPr = list.Where(a => a.pr_billno.StartsWith("PR")).ToList();
            if (zcPr.Any())
            {
                AutoCreateZCPOFromPR(zcPr, bangid, input);
            }

            var wwPr = list.Where(a => a.pr_billno.StartsWith("WWPR")).ToList();
            if (wwPr.Any())
            {
                AutoCreateWWPOFromPR(wwPr, bangid, input);
            }
        }
        private void AutoCreateZCPOFromPR(List<mo_srm_pr_main> list, long bangid, ResourceCheckInputDto input)
        {
            List<mo_srm_po_main> polist = new List<mo_srm_po_main>();
            List<mo_srm_po_list> podetaillist = new List<mo_srm_po_list>();
            var itemList = _ic_item.Find(a => a.tenant_id == input.tenantId && a.factory_id == input.factoryId).Result;
            //将PR按供应商和物料和日期（一周内）进行合并，生成PO
            //1.按照供应商、需求日期排序
            //2.判断是不是同一个供应商，不是的话就新建一个PO；是的话判断是不是同一周，不是的话就新建一个PO，是的话判断有没有相同物料，有的话合并物料数量价格，没有的话新建一条明细
            list = list.OrderBy(a => a.pr_purchaseid).ThenBy(b => b.pr_rarrive_date).ToList();
            long? supplierId = -1;
            DateTime supplierDate = DateTime.Now;
            foreach (mo_srm_pr_main item in list)
            {
                if (item.pr_purchaseid != supplierId)
                {
                    var itemsupplier = _srm_supplier.Find(a => a.mysql_id == item.pr_purchaseid && a.tenant_id == input.tenantId && a.factory_id == input.factoryId).Result;
                    //新建一个PO
                    mo_srm_po_main po_Main = new mo_srm_po_main();
                    po_Main.id = help.NextId();
                    po_Main.mysql_id = help.NextId();
                    po_Main.po_billno = GetMaxSerialNumber(416188684804165);
                    po_Main.po_purchaser = item.pr_purchaser;
                    po_Main.po_purchaser_no = item.pr_purchaser_num;
                    po_Main.po_ssend_date = DateTime.Now;
                    po_Main.po_total = item.pr_orderprice;
                    po_Main.po_tax_rate = item.pr_rate;
                    po_Main.po_express = 1;
                    po_Main.state = 0;
                    po_Main.po_note = "PR自动转PO";
                    po_Main.po_order_type = 1;
                    po_Main.currency = item.currencytype;
                    po_Main.bill_type = 1;
                    po_Main.supplier_id = item.pr_purchaseid;
                    po_Main.supplier_name = item.pr_purchasename;
                    po_Main.supplier_no = item.pr_purchasenumber;
                    po_Main.contact = itemsupplier is null? itemsupplier?.FirstOrDefault().contact:"";
                    po_Main.suppliertelephone = itemsupplier is null ? itemsupplier?.FirstOrDefault().telephone:"";
                    po_Main.deliveryaddress = "";
                    po_Main.supplierdddress = itemsupplier is null ? itemsupplier?.FirstOrDefault().supplier_address:"";
                    po_Main.confirmstate = 1;
                    po_Main.logisticsstate = 0;
                    po_Main.financialstate = 0;
                    po_Main.create_time = DateTime.Now;
                    po_Main.factory_id = input.factoryId;
                    po_Main.tenant_id = input.tenantId;
                    po_Main.bang_id = bangid;
                    po_Main.po_delivery = 1;
                    polist.Add(po_Main);

                    mo_srm_po_list podetail = new mo_srm_po_list();
                    podetail.id = help.NextId();
                    podetail.mysql_id = help.NextId();
                    podetail.po_id = po_Main.mysql_id;
                    podetail.po_billno = po_Main.po_billno;
                    podetail.polist_row = podetaillist.Where(a=>a.po_billno== po_Main.po_billno).Count() + 1;
                    podetail.pr_id = item.mysql_id;
                    podetail.pr_billno = item.pr_billno;
                    podetail.pr_purchase_id = po_Main.supplier_id;
                    podetail.pr_purchase_name = po_Main.supplier_name;
                    podetail.icitem_id = item.icitem_id;
                    podetail.ItemNum = itemList.First(a => a.mysql_id == item.icitem_id).number;
                    podetail.icitem_name = item.icitem_name;
                    podetail.qty = item.pr_aqty;
                    podetail.netprice = item.pr_price;
                    podetail.rate = item.pr_rate;
                    podetail.price = item.pr_orderprice / item.pr_aqty;
                    podetail.total_price = item.pr_orderprice;
                    podetail.plan_qty = item.pr_aqty;
                    podetail.unit = item.pr_unit;
                    podetail.state = item.state;
                    podetail.rarrdate = item.pr_rarrive_date;
                    podetail.rnumber = 0;
                    podetail.currencytype = item.currencytype;
                    podetail.create_time = DateTime.Now;
                    podetail.factory_id = input.factoryId;
                    podetail.tenant_id = input.tenantId;
                    podetail.bang_id = bangid;
                    podetail.stock_id = 1;
                    podetaillist.Add(podetail);

                    supplierId = item.pr_purchaseid;
                    supplierDate = item.pr_rarrive_date.Value;
                }
                else
                {
                    //同一个供应商先判断需求日期是否在同一周
                    if (IsSameWeek(supplierDate, item.pr_rarrive_date.Value))
                    {
                        var pomain = polist.FindAll(x => x.supplier_id == item.pr_purchaseid).OrderByDescending(b => b.create_time).First();
                        List<mo_srm_po_list> detail = podetaillist.FindAll(a => a.po_billno == pomain.po_billno && a.icitem_id == item.icitem_id);
                        if (detail.Count > 0)
                        {
                            //TODO:只能记录一条PR，可能需要先合PR
                            //存在同一种物料，存在就计算数量和价格，
                            detail[0].qty = detail[0].qty + item.pr_aqty;
                            detail[0].netprice = detail[0].netprice + item.pr_price;
                            detail[0].total_price = detail[0].total_price + item.pr_orderprice;
                            detail[0].plan_qty = detail[0].plan_qty + item.pr_aqty;
                            detail[0].rarrdate = item.pr_rarrive_date;
                            pomain.po_total = pomain.po_total + item.pr_orderprice;
                        }
                        else
                        {
                            //不存在同一种物料新增一条明细
                            mo_srm_po_list podetail = new mo_srm_po_list();
                            podetail.id = help.NextId();
                            podetail.mysql_id = help.NextId();
                            podetail.po_id = pomain.mysql_id;
                            podetail.po_billno = pomain.po_billno;
                            podetail.polist_row = podetaillist.Where(a => a.po_billno == pomain.po_billno).Count() + 1;
                            podetail.pr_id = item.mysql_id;
                            podetail.pr_billno = item.pr_billno;
                            podetail.pr_purchase_id = pomain.supplier_id;
                            podetail.pr_purchase_name = pomain.supplier_name;
                            podetail.icitem_id = item.icitem_id;
                            podetail.ItemNum = itemList.First(a => a.mysql_id == item.icitem_id).number;
                            podetail.icitem_name = item.icitem_name;
                            podetail.qty = item.pr_aqty;
                            podetail.netprice = item.pr_price;
                            podetail.rate = item.pr_rate;
                            podetail.price = item.pr_orderprice / item.pr_aqty;
                            podetail.total_price = item.pr_orderprice;
                            podetail.plan_qty = item.pr_aqty;
                            podetail.unit = item.pr_unit;
                            podetail.state = item.state;
                            podetail.rarrdate = item.pr_rarrive_date;
                            podetail.rnumber = 0;
                            podetail.currencytype = item.currencytype;
                            podetail.create_time = DateTime.Now;
                            podetail.factory_id = input.factoryId;
                            podetail.tenant_id = input.tenantId;
                            podetail.bang_id = bangid;
                            podetaillist.Add(podetail);
                            podetail.stock_id = 1;
                            pomain.po_total = pomain.po_total + item.pr_orderprice;
                        }

                    }
                    else
                    {
                        //不在同一周需要新建一张PO
                        var itemsupplier = _srm_supplier.Find(a => a.mysql_id == item.pr_purchaseid && a.tenant_id == input.tenantId && a.factory_id == input.factoryId).Result;
                        //新建一个PO单
                        mo_srm_po_main po_Main = new mo_srm_po_main();
                        po_Main.id = help.NextId();
                        po_Main.mysql_id = help.NextId();
                        po_Main.po_billno = GetMaxSerialNumber(416188684804165);
                        po_Main.po_purchaser = item.pr_purchaser;
                        po_Main.po_purchaser_no = item.pr_purchaser_num;
                        po_Main.po_ssend_date = DateTime.Now;
                        po_Main.po_total = item.pr_orderprice;
                        po_Main.po_tax_rate = item.pr_rate;
                        po_Main.po_express = 1;
                        po_Main.state = 0;
                        po_Main.po_note = "PR自动转PO";
                        po_Main.po_order_type = 1;
                        po_Main.currency = item.currencytype;
                        po_Main.bill_type = 1;
                        po_Main.supplier_id = item.pr_purchaseid;
                        po_Main.supplier_name = item.pr_purchasename;
                        po_Main.supplier_no = item.pr_purchasenumber;
                        po_Main.contact = itemsupplier is null ? itemsupplier?.FirstOrDefault().contact:"";
                        po_Main.suppliertelephone = itemsupplier is null ? itemsupplier?.FirstOrDefault().telephone:"";
                        po_Main.deliveryaddress = "";
                        po_Main.supplierdddress = itemsupplier is null ? itemsupplier?.FirstOrDefault().supplier_address:"";
                        po_Main.confirmstate = 1;
                        po_Main.logisticsstate = 0;
                        po_Main.financialstate = 0;
                        po_Main.create_time = DateTime.Now;
                        po_Main.factory_id = input.factoryId;
                        po_Main.tenant_id = input.tenantId;
                        po_Main.bang_id = bangid;
                        po_Main.po_delivery = 1;
                        polist.Add(po_Main);

                        mo_srm_po_list podetail = new mo_srm_po_list();
                        podetail.id = help.NextId();
                        podetail.mysql_id = help.NextId();
                        podetail.po_id = po_Main.mysql_id;
                        podetail.po_billno = po_Main.po_billno;
                        podetail.polist_row = podetaillist.Where(a => a.po_billno == po_Main.po_billno).Count() + 1;
                        podetail.pr_id = item.mysql_id;
                        podetail.pr_billno = item.pr_billno;
                        podetail.pr_purchase_id = po_Main.supplier_id;
                        podetail.pr_purchase_name = po_Main.supplier_name;
                        podetail.icitem_id = item.icitem_id;
                        podetail.ItemNum = itemList.First(a => a.mysql_id == item.icitem_id).number;
                        podetail.icitem_name = item.icitem_name;
                        podetail.qty = item.pr_aqty;
                        podetail.netprice = item.pr_price;
                        podetail.rate = item.pr_rate;
                        podetail.price = item.pr_orderprice / item.pr_aqty;
                        podetail.total_price = item.pr_orderprice;
                        podetail.plan_qty = item.pr_aqty;
                        podetail.unit = item.pr_unit;
                        podetail.state = item.state;
                        podetail.rarrdate = item.pr_rarrive_date;
                        podetail.rnumber = 0;
                        podetail.currencytype = item.currencytype;
                        podetail.create_time = DateTime.Now;
                        podetail.factory_id = input.factoryId;
                        podetail.tenant_id = input.tenantId;
                        podetail.bang_id = bangid;
                        podetail.stock_id = 1;
                        podetaillist.Add(podetail);

                        supplierId = item.pr_purchaseid;
                        supplierDate = item.pr_rarrive_date.Value;
                    }
                }
            }
            _srm_po_main.InsertMany(polist);
            _srm_po_list.InsertMany(podetaillist);
            List<srm_po_main> po_mainlist = ObjectMapper.Map<List<mo_srm_po_main>, List<srm_po_main>>(polist);
            _businessDbContext.BulkInsert(po_mainlist);
            var po_listlist = ObjectMapper.Map<List<mo_srm_po_list>, List<srm_po_list>>(podetaillist);
            _businessDbContext.BulkInsert(po_listlist);
        }
        private void AutoCreateWWPOFromPR(List<mo_srm_pr_main> list, long bangid, ResourceCheckInputDto input)
        {
            List<mo_srm_po_main> polist = new List<mo_srm_po_main>();
            List<mo_srm_po_list> podetaillist = new List<mo_srm_po_list>();
            var itemList = _ic_item.Find(a => a.tenant_id == input.tenantId && a.factory_id == input.factoryId).Result;
            //将PR按供应商和物料和日期（一周内）进行合并，生成PO
            //1.按照供应商、需求日期排序
            //2.判断是不是同一个供应商，不是的话就新建一个PO；是的话判断是不是同一周，不是的话就新建一个PO，是的话判断有没有相同物料，有的话合并物料数量价格，没有的话新建一条明细
            list = list.OrderBy(a => a.pr_purchaseid).ThenBy(b => b.pr_rarrive_date).ToList();
            long? supplierId = -1;
            DateTime supplierDate = DateTime.Now;
            foreach (var item in list)
            {
                if (item.pr_purchaseid != supplierId)
                {
                    var itemsupplier = _srm_supplier.Find(a => a.mysql_id == item.pr_purchaseid && a.tenant_id == input.tenantId && a.factory_id == input.factoryId).Result;
                    //新建一个PO
                    mo_srm_po_main po_Main = new mo_srm_po_main();
                    po_Main.id = help.NextId();
                    po_Main.mysql_id = help.NextId();
                    po_Main.po_billno = GetMaxSerialNumber(416555323363397);//WWPO
                    po_Main.po_purchaser = item.pr_purchaser;
                    po_Main.po_purchaser_no = item.pr_purchaser_num;
                    po_Main.po_ssend_date = DateTime.Now;
                    po_Main.po_total = item.pr_orderprice;
                    po_Main.po_tax_rate = item.pr_rate;
                    po_Main.po_express = 1;
                    po_Main.state = 0;
                    po_Main.po_note = "PR自动转PO";
                    po_Main.po_order_type = 1;
                    po_Main.currency = item.currencytype;
                    po_Main.bill_type = 1;
                    po_Main.supplier_id = item.pr_purchaseid;
                    po_Main.supplier_name = item.pr_purchasename;
                    po_Main.supplier_no = item.pr_purchasenumber;
                    po_Main.contact = itemsupplier is null ? itemsupplier?.FirstOrDefault().contact:"";
                    po_Main.suppliertelephone = itemsupplier is null ? itemsupplier?.FirstOrDefault().telephone:"";
                    po_Main.deliveryaddress = "";
                    po_Main.supplierdddress = itemsupplier is null ? itemsupplier?.FirstOrDefault().supplier_address:"";
                    po_Main.confirmstate = 1;
                    po_Main.logisticsstate = 0;
                    po_Main.financialstate = 0;
                    po_Main.create_time = DateTime.Now;
                    po_Main.factory_id = input.factoryId;
                    po_Main.tenant_id = input.tenantId;
                    po_Main.bang_id = bangid;
                    po_Main.po_delivery = 1;
                    polist.Add(po_Main);

                    mo_srm_po_list podetail = new mo_srm_po_list();
                    podetail.id = help.NextId();
                    podetail.mysql_id = help.NextId();
                    podetail.po_id = po_Main.mysql_id;
                    podetail.po_billno = po_Main.po_billno;
                    podetail.polist_row = podetaillist.Where(a => a.po_billno == po_Main.po_billno).Count() + 1;
                    podetail.pr_id = item.mysql_id;
                    podetail.pr_billno = item.pr_billno;
                    podetail.pr_purchase_id = po_Main.supplier_id;
                    podetail.pr_purchase_name = po_Main.supplier_name;
                    podetail.icitem_id = item.icitem_id;
                    podetail.ItemNum = itemList.First(a => a.mysql_id == item.icitem_id).number;
                    podetail.icitem_name = item.icitem_name;
                    podetail.qty = item.pr_aqty;
                    podetail.netprice = item.pr_price;
                    podetail.rate = item.pr_rate;
                    podetail.price = item.pr_orderprice / item.pr_aqty;
                    podetail.total_price = item.pr_orderprice;
                    podetail.plan_qty = item.pr_aqty;
                    podetail.unit = item.pr_unit;
                    podetail.state = item.state;
                    podetail.rarrdate = item.pr_rarrive_date;
                    podetail.rnumber = 0;
                    podetail.currencytype = item.currencytype;
                    podetail.create_time = DateTime.Now;
                    podetail.factory_id = input.factoryId;
                    podetail.tenant_id = input.tenantId;
                    podetail.bang_id = bangid;
                    podetail.stock_id = 1;
                    podetaillist.Add(podetail);

                    supplierId = item.pr_purchaseid;
                    supplierDate = item.pr_rarrive_date.Value;
                }
                else
                {
                    //同一个供应商先判断需求日期是否在同一周
                    if (IsSameWeek(supplierDate, item.pr_rarrive_date.Value))
                    {
                        var pomain = polist.FindAll(x => x.supplier_id == item.pr_purchaseid).OrderByDescending(b => b.create_time).First();
                        List<mo_srm_po_list> detail = podetaillist.FindAll(a => a.po_billno == pomain.po_billno && a.icitem_id == item.icitem_id);
                        if (detail.Count > 0)
                        {
                            //TODO:只能记录一条PR，可能需要先合PR
                            //存在同一种物料，存在就计算数量和价格，
                            detail[0].qty = detail[0].qty + item.pr_aqty;
                            detail[0].netprice = detail[0].netprice + item.pr_price;
                            detail[0].total_price = detail[0].total_price + item.pr_orderprice;
                            detail[0].plan_qty = detail[0].plan_qty + item.pr_aqty;
                            detail[0].rarrdate = item.pr_rarrive_date;
                            pomain.po_total = pomain.po_total + item.pr_orderprice;
                        }
                        else
                        {
                            //不存在同一种物料新增一条明细
                            mo_srm_po_list podetail = new mo_srm_po_list();
                            podetail.id = help.NextId();
                            podetail.mysql_id = help.NextId();
                            podetail.po_id = pomain.mysql_id;
                            podetail.po_billno = pomain.po_billno;
                            podetail.polist_row = podetaillist.Where(a => a.po_billno == pomain.po_billno).Count() + 1;
                            podetail.pr_id = item.mysql_id;
                            podetail.pr_billno = item.pr_billno;
                            podetail.pr_purchase_id = pomain.supplier_id;
                            podetail.pr_purchase_name = pomain.supplier_name;
                            podetail.icitem_id = item.icitem_id;
                            podetail.ItemNum = itemList.First(a => a.mysql_id == item.icitem_id).number;
                            podetail.icitem_name = item.icitem_name;
                            podetail.qty = item.pr_aqty;
                            podetail.netprice = item.pr_price;
                            podetail.rate = item.pr_rate;
                            podetail.price = item.pr_orderprice / item.pr_aqty;
                            podetail.total_price = item.pr_orderprice;
                            podetail.plan_qty = item.pr_aqty;
                            podetail.unit = item.pr_unit;
                            podetail.state = item.state;
                            podetail.rarrdate = item.pr_rarrive_date;
                            podetail.rnumber = 0;
                            podetail.currencytype = item.currencytype;
                            podetail.create_time = DateTime.Now;
                            podetail.factory_id = input.factoryId;
                            podetail.tenant_id = input.tenantId;
                            podetail.bang_id = bangid;
                            podetail.stock_id = 1;
                            podetaillist.Add(podetail);
                            pomain.po_total = pomain.po_total + item.pr_orderprice;
                        }

                    }
                    else
                    {
                        //不在同一周需要新建一张PO
                        var itemsupplier = _srm_supplier.Find(a => a.mysql_id == item.pr_purchaseid && a.tenant_id == input.tenantId && a.factory_id == input.factoryId).Result;
                        //新建一个PO单
                        mo_srm_po_main po_Main = new mo_srm_po_main();
                        po_Main.id = help.NextId();
                        po_Main.mysql_id = help.NextId();
                        po_Main.po_billno = GetMaxSerialNumber(416555323363397);
                        po_Main.po_purchaser = item.pr_purchaser;
                        po_Main.po_purchaser_no = item.pr_purchaser_num;
                        po_Main.po_ssend_date = DateTime.Now;
                        po_Main.po_total = item.pr_orderprice;
                        po_Main.po_tax_rate = item.pr_rate;
                        po_Main.po_express = 1;
                        po_Main.state = 0;
                        po_Main.po_note = "PR自动转PO";
                        po_Main.po_order_type = 1;
                        po_Main.currency = item.currencytype;
                        po_Main.bill_type = 1;
                        po_Main.supplier_id = item.pr_purchaseid;
                        po_Main.supplier_name = item.pr_purchasename;
                        po_Main.supplier_no = item.pr_purchasenumber;
                        po_Main.contact = itemsupplier is null ? itemsupplier?.FirstOrDefault().contact:"";
                        po_Main.suppliertelephone = itemsupplier is null ? itemsupplier?.FirstOrDefault().telephone:"";
                        po_Main.deliveryaddress = "";
                        po_Main.supplierdddress = itemsupplier is null ? itemsupplier?.FirstOrDefault().supplier_address:"";
                        po_Main.confirmstate = 1;
                        po_Main.logisticsstate = 0;
                        po_Main.financialstate = 0;
                        po_Main.create_time = DateTime.Now;
                        po_Main.factory_id = input.factoryId;
                        po_Main.tenant_id = input.tenantId;
                        po_Main.bang_id = bangid;
                        po_Main.po_delivery = 1;
                        polist.Add(po_Main);

                        mo_srm_po_list podetail = new mo_srm_po_list();
                        podetail.id = help.NextId();
                        podetail.mysql_id = help.NextId();
                        podetail.po_id = po_Main.mysql_id;
                        podetail.po_billno = po_Main.po_billno;
                        podetail.polist_row = podetaillist.Where(a => a.po_billno == po_Main.po_billno).Count() + 1;
                        podetail.pr_id = item.mysql_id;
                        podetail.pr_billno = item.pr_billno;
                        podetail.pr_purchase_id = po_Main.supplier_id;
                        podetail.pr_purchase_name = po_Main.supplier_name;
                        podetail.icitem_id = item.icitem_id;
                        podetail.ItemNum = itemList.First(a => a.mysql_id == item.icitem_id).number;
                        podetail.icitem_name = item.icitem_name;
                        podetail.qty = item.pr_aqty;
                        podetail.netprice = item.pr_price;
                        podetail.rate = item.pr_rate;
                        podetail.price = item.pr_orderprice / item.pr_aqty;
                        podetail.total_price = item.pr_orderprice;
                        podetail.plan_qty = item.pr_aqty;
                        podetail.unit = item.pr_unit;
                        podetail.state = item.state;
                        podetail.rarrdate = item.pr_rarrive_date;
                        podetail.rnumber = 0;
                        podetail.currencytype = item.currencytype;
                        podetail.create_time = DateTime.Now;
                        podetail.factory_id = input.factoryId;
                        podetail.tenant_id = input.tenantId;
                        podetail.bang_id = bangid;
                        podetail.stock_id = 1;
                        podetaillist.Add(podetail);

                        supplierId = item.pr_purchaseid;
                        supplierDate = item.pr_rarrive_date.Value;
                    }
                }
            }
            _srm_po_main.InsertMany(polist);
            _srm_po_list.InsertMany(podetaillist);
            List<srm_po_main> po_mainlist = ObjectMapper.Map<List<mo_srm_po_main>, List<srm_po_main>>(polist);
            _businessDbContext.BulkInsert(po_mainlist);
            var po_listlist = ObjectMapper.Map<List<mo_srm_po_list>, List<srm_po_list>>(podetaillist);
            _businessDbContext.BulkInsert(po_listlist);
        }

        /// <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, icitemlist, stocklist, pretreatments);
            _morderAppService.param = param;
            _purchaseOrderAppService.param = param;
            _CalcBomViewAppService.param = param;
            foreach (var item in mo_Mes_Morders)
            {
                var moentry = mo_Mes_Moentries.Find(s => s.moentry_moid == item.Id);
                if (moentry == null)
                {
                    continue;
                }
                var sentry = sentrys.Find(s => s.Id == moentry.soentry_id);

                //工单资源检查信息
                ExamineResult dtl = new ExamineResult();
                dtl.morder_id = item.Id;
                dtl.morder_no = item.morder_no;

                dtl.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, item.urgent, 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, 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<string> itemnums = pretreatments.Where(p => p.level == 1).Select(p => p.item_number).Distinct().ToList();
            //产线明细
            prodLines = _prodLineDetail.Select(p=> itemnums.Contains(p.Part)).ToList();
            //标准工序
            routingOps = _routingOpDetail.Select(p => itemnums.Contains(p.RoutingCode)).ToList();
            List<string> lines = prodLines.Select(p=>p.Line).Distinct().ToList();
            //工作日历
            calendarWorks = _shopCalendarWorkCtr.Select(p=>lines.Contains(p.ProdLine)).ToList();
            //休息日
            qualityLineWorks = _qualityLineWorkDetail.Select(p => lines.Contains(p.ProdLine)).ToList();
            //节假日
            holidays = _holidayMaster.Select(p => p.Dated >= DateTime.Now.Date);

            //主工单
            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.tenant_id == param.tenantId && x.bang_id == bangid).Result;
            List<long> moids = mo_Mes_Morders.Select(p => p.mysql_id).ToList();
            List<mo_mes_moentry> mo_Mes_Moentry = _mes_moentry.GetManyByCondition(x => moids.Contains(x.moentry_moid)).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列表

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

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

            _CalcBomViewAppService.mordersList = mo_Mes_Morders;//工单
            _CalcBomViewAppService.moentriesList = mo_Mes_Moentry;//工单子表
            _CalcBomViewAppService.mooccupyAllList = mes_mooccupyList;//工单占用表
            
            _CalcBomViewAppService.srm_Po_Lists = poDetailList; //采购明细
            _CalcBomViewAppService.srm_Po_Occupies = poOccupys; //采购占用表
        }

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

        public void AutoCreatePickBill(List<string> workOrds)
        {
            //获取生产周期数据
            List<PeriodSequenceDet> dbPeriodSequences = _periodSequenceDet.Select(p => workOrds.Contains(p.WorkOrds) && p.Domain == "1001" && p.IsActive);
            List<NbrMaster> nbrMasterList = new List<NbrMaster>();//需要生成领料单列表
            List<NbrDetail> nbrDetailList = new List<NbrDetail>();//需要生成领料单明细列表
            if (dbPeriodSequences.Any())
            {
                //按照工单领料，一个工单一个领料单，之前是按照排产日期和产线分别领料
                foreach(var workord in workOrds)
                {
                    Dictionary<string, decimal> dictItemQty = new Dictionary<string, decimal>();
                    List<string> lines = dbPeriodSequences.Where(a=>a.WorkOrds==workord).Select(a => a.Line).Distinct().ToList();
                    List<LineMaster> lineMasters = _lineMaster.Select(p => lines.Contains(p.Line) && p.Domain == "1001" && p.IsActive);
                    List<ProductStructureMaster> itemList = GetProductStructure(dbPeriodSequences.Where(a => a.WorkOrds == workord).Select(a => a.ItemNum).Distinct().ToList());
                    var childrenList = itemList.Select(a => a.ComponentItem).Distinct().ToList();
                    List<ItemMaster> itemLocList = _itemMaster.Select(p => childrenList.Contains(p.ItemNum) && p.Domain == "1001" && p.IsActive).Distinct().ToList();
                    List<ItemPackMaster> itemPackList = _itemPackMaster.Select(p => childrenList.Contains(p.ItemNum) && p.Domain == "1001" && p.IsActive).Distinct().ToList();
                    var Nbr = GetMaxSerialNumber(417416915624005);
                    //根据某一产线汇总即该工单的总数
                    decimal QtyOrdSum = dbPeriodSequences.Where(a => a.WorkOrds == workord && a.Line == lines[0]).Sum(a => a.OrdQty.GetValueOrDefault());
                    nbrMasterList.Add(new NbrMaster
                    {
                        Domain = "1001",
                        Type = "SM",
                        Nbr = Nbr,
                        Remark = "排产自动领料",
                        Date = dbPeriodSequences.Where(a => a.WorkOrds == workord).Min(a=>a.PlanDate),
                        //ProdLine = item.Line,
                        Status = "",
                        WorkOrd = workord,
                        QtyOrd = QtyOrdSum,
                        IsActive = true,
                        IsChanged = true,
                        Name = "1001",
                        Department = "101",
                        CreateTmie = DateTime.Now,
                        UpdateTmie = DateTime.Now,
                        CreateUser = "1001",
                        UpdateUser = "1001"
                    });
                    int i = 1;
                    itemList?.ForEach(a =>
                    {
                        var find = itemLocList?.Find(c => c.ItemNum == a.ComponentItem);
                        string LocationTo = "";
                        if (find!=null)
                        {
                            LocationTo=find.Location;
                        }
                        //相同物料汇总
                        var itemComponent = nbrDetailList.Find(b => b.Nbr == Nbr && b.ItemNum == a.ComponentItem);
                        if (itemComponent==null)
                        {
                            nbrDetailList.Add(new NbrDetail
                            {
                                Domain = "1001",
                                Type = "SM",
                                Nbr = Nbr,
                                ItemNum = a.ComponentItem,
                                QtyFrom = 0,
                                QtyTo = 0,
                                LocationFrom = LocationTo,
                                LocationTo = "",
                                WorkOrd = workord,
                                QtyOrd =QtyOrdSum * a.Qty,
                                CurrQtyOpened = QtyOrdSum * a.Qty ,
                                Line = i,
                                IsActive = true,
                                CreateTmie = DateTime.Now,
                                UpdateTmie = DateTime.Now,
                                CreateUser = "1001",
                                UpdateUser = "1001",
                                UM = a.UM
                            });
                            i++;
                        }
                        else
                        {
                            nbrDetailList.First( b=> b.Nbr == Nbr && b.ItemNum == a.ComponentItem).QtyOrd= itemComponent.QtyOrd+ QtyOrdSum * a.Qty;
                            nbrDetailList.First(b => b.Nbr == Nbr && b.ItemNum == a.ComponentItem).CurrQtyOpened = itemComponent.CurrQtyOpened + QtyOrdSum * a.Qty;
                        }
                    });
                    nbrDetailList.ForEach(a => 
                    {
                        var find = itemLocList?.Find(c => c.ItemNum == a.ItemNum);
                        var packfind = itemPackList?.Find(c => c.ItemNum == a.ItemNum);
                        if(find!=null && !find.TraceDetail && packfind!=null && packfind.PackingQty>0)
                        {
                            a.CurrQtyOpened = Math.Ceiling(a.CurrQtyOpened.GetValueOrDefault() / packfind.PackingQty.GetValueOrDefault()) * packfind.PackingQty;
                            dictItemQty.Add(a.ItemNum, QtyOrdSum * itemList.First(b => b.ComponentItem == a.ItemNum).Qty);
                        }
                        else
                        {
                            dictItemQty.Add(a.ItemNum, QtyOrdSum * itemList.First(b => b.ComponentItem == a.ItemNum).Qty);
                        }
                    });
                    List<string> itemKeys = dictItemQty.Keys.ToList();
                    //var items = _mysql_ic_item.GetListAsync(a => itemKeys.Contains(a.number) && a.factory_id == 1001 && a.tenant_id == 1000).Result;
                    //var itemIds = items.Select(b => b.Id).ToList();
                    //var leadTimes = GetLeadTime(itemIds, 1000, 1001).Max(a=>a.ordissu_days.GetValueOrDefault());
                    decimal leadTimes=itemLocList.Select(a => a.MFGMTTR).Max();
                    //没有维护备料提前期，默认取7天
                    if (leadTimes > 0)
                    {
                        nbrMasterList.First(a => a.Nbr == Nbr).Date = dbPeriodSequences.Where(a => a.WorkOrds == workord).Min(a => a.PlanDate).GetValueOrDefault().AddDays(-1 * Convert.ToDouble(leadTimes));
                    }
                    else
                    {
                        nbrMasterList.First(a => a.Nbr == Nbr).Date = dbPeriodSequences.Where(a => a.WorkOrds == workord).Min(a => a.PlanDate).GetValueOrDefault().AddDays(-7);
                    }
                    //TODO:
                    //因为我们并没有模拟发料的过程,在自动生成领料单的时候就要扣减库存，实际业务不能这么做。
                    //在有上料和追溯的系统，可以在扫码上料或报工时（从线边仓）扣减。或者在实际发料出库时扣减。
                    var locStock=_locationDetail.Select(a => itemKeys.Contains(a.ItemNum) && a.IsActive && a.Domain == "1001");
                    locStock?.ForEach(a =>
                    {
                        nbrDetailList.ForEach(b =>
                        {
                            if(a.ItemNum==b.ItemNum && a.Location==b.LocationFrom && a.QtyOnHand - dictItemQty[a.ItemNum] > 0)
                            {
                                a.QtyOnHand = a.QtyOnHand - dictItemQty[a.ItemNum];
                            }
                        });
                    });
                    _locationDetail.Update(locStock);
                }
                _nbrMaster.Insert(nbrMasterList);
                //快开平台用自增列RecId关联，所以需要插入后再查给明细表赋相应的值
                List<string> nbrs = nbrMasterList.Select(a => a.Nbr).ToList();
                var nbrList = _nbrMaster.Select(a => a.Domain == "1001" && a.Type == "SM" && nbrs.Contains(a.Nbr));
                nbrDetailList.ForEach(c =>
                {
                    c.NbrRecID = nbrList.Where(a => a.Nbr == c.Nbr).First().RecID;
                });
                _nbrDetail.Insert(nbrDetailList);
            }
        }

        public void AsyncItemStockFromWMS(List<crm_seorderentry> sentrys)
        {
            //产品编码
            var itemList = sentrys.Select(a => a.item_number).Distinct().ToList();
            List<string> itemChildList = new List<string>();
            itemList.ForEach(a =>
            {
                itemChildList.AddRange(GetChildItemNumber(a, new List<string>()));
            });
            var stockList = _locationDetail.Select(a => a.Domain == "1001" && a.IsActive && itemChildList.Distinct().Contains(a.ItemNum));
            var groupList = stockList.
                GroupBy(m => new { m.ItemNum }).
                Select(a => new { ItemNum = a.Key.ItemNum, Qty = a.Sum(c => c.QtyOnHand) }).ToList();
            var itemNums = groupList.Select(b => b.ItemNum).ToList();//需要处理的dop物料编码集合
            var items = _mysql_ic_item.GetListAsync(a => itemNums.Contains(a.number) && a.factory_id == 1001 && a.tenant_id == 1000).Result;
            var itemIds = items.Select(b => b.Id).ToList();//需要处理的dop物料id集合
            List<ic_item_stock> mysqlStock = _mysql_ic_item_stock.GetListAsync(a => itemIds.Contains(a.Id) && a.factory_id == 1001 && a.tenant_id == 1000).Result;
            List<ic_item_stock> needAddList = new List<ic_item_stock>();

            foreach(var stockWMS in groupList)
            {
                foreach (var num in items)
                {
                    if (stockWMS.ItemNum==num.number)
                    {
                        var item = mysqlStock.Find(a => a.Id == num.Id);
                        if(item!=null)
                        {
                            item.sqty = groupList.First(a => a.ItemNum == num.number).Qty;
                        }else
                        {
                            ic_item_stock stock= new ic_item_stock();
                            stock.GenerateNewId();
                            stock.factory_id = 1001;
                            stock.tenant_id = 1000;
                            stock.icitem_id = num.Id;
                            stock.icitem_name = num.name;
                            stock.sqty= groupList.First(a => a.ItemNum == num.number).Qty;
                        }
                        break;
                    }
                };
            }
            if(needAddList.Count>0)
            {
                _businessDbContext.BulkInsert(needAddList);
            }
            _businessDbContext.BulkUpdate(mysqlStock);
        }
        //循环获取子级物料编码，包括产品本身，有重复的结果去重即可
        public List<string> GetChildItemNumber(string itemNum,List<string> list)
        {
            list.Add(itemNum);
            var productStructures = _productStructureMaster.Select(p =>p.ParentItem== itemNum && p.Domain == "1001" && p.IsActive);
            list.AddRange(productStructures.Select(a=>a.ComponentItem));
            foreach (var item in productStructures)
            {
                if(item.StructureType.ToUpper()=="X")
                {
                    GetChildItemNumber(item.ComponentItem, list);
                }
            }
            return list;
        }

        /// <summary>
        /// 得到一个流水号的最大流水号
        /// </summary>
        /// <param name="id">流水号id</param>
        /// <param name="formData">json数据，可以用json中的某个字段值作为通配符字替换流水号格式。</param>
        /// <returns></returns>
        public string GetMaxSerialNumber(long id, JObject? formData = null)
        {
            var modelList = _rf_serialnumber.Select(s => s.Id == id);
            if (modelList == null && modelList.Count < 1)
            {
                return string.Empty;
            }
            var model = modelList[0];
            int max = model.CurrentNumber + 1;
            var date = DateTime.Now;
            var lastDate = model.LastTime;
            switch (model.NumberType)
            {
                case 1: //年流水
                    if (date.Year > lastDate.Year)
                    {
                        max = 1;
                    }
                    break;
                case 2: //月流水
                    if (date.Year > lastDate.Year || date.Month > lastDate.Month)
                    {
                        max = 1;
                    }
                    break;
                case 3: //日流水
                    if (date.Year > lastDate.Year || date.Month > lastDate.Month || date.Day > lastDate.Day)
                    {
                        max = 1;
                    }
                    break;
            }
            string number = max.ToString().PadLeft(model.NumberSize, '0');
            string serialNumber = string.IsNullOrWhiteSpace(model.Format) ? number
                : model.Format.ContainsIgnoreCase("{number}")
                ? model.Format.ReplaceIgnoreCase("{number}", number)
                : model.Format + number;
            //更新当前编号和最后时间
            model.LastTime = date;
            model.CurrentNumber = max;
            _rf_serialnumber.Update(model);
            return Wildcard.Replace(serialNumber, formData);
        }

        /// <summary>
        /// 生产排产
        /// </summary>
        /// <param name="workOrds"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<string> ProductionSchedule(List<string> workOrds)
        {
            if (workOrds.Count() == 0)
            {
                return "";
            }
            //获取工单数据
            var workOrdMasters = _workOrdMaster.Select(p => workOrds.Contains(p.WorkOrd));
            //获取已排产的工单
            List<string> dbWorkOrds = _periodSequenceDet.Select(p => workOrds.Contains(p.WorkOrds)).Select(p => p.WorkOrds).Distinct().ToList();
            //过滤掉已排产的工单
            workOrdMasters = workOrdMasters.Where(p => !dbWorkOrds.Contains(p.WorkOrd)).ToList();
            //排产
            await _productionScheduleAppService.DoProductShcedule(workOrdMasters);
            AutoCreatePickBill(workOrds);
            return JsonConvert.SerializeObject("ok");
        }

        /// <summary>
        /// 同步工单等相关数据
        /// </summary>
        /// <param name="morders"></param>
        public void CreateWorkOrdDates(List<mes_morder> morders)
        {
            //获取工艺路线数据：product_code=物料编码
            List<RoutingOpDetail> allRoutings = _routingOpDetail.Select(p => morders.Select(m => m.product_code).Contains(p.RoutingCode));
            //获取标准BOM数据
            List<ProductStructureMaster> productStructures = GetProductStructure(morders.Select(p => p.product_code).Distinct().ToList());

            //工单主表
            List<WorkOrdMaster> workOrds = new List<WorkOrdMaster>();
            WorkOrdMaster workOrd;
            //工单工艺路线表
            List<WorkOrdRouting> workOrdRoutings = new List<WorkOrdRouting>();
            WorkOrdRouting woRouting;
            //工单物料表
            List<WorkOrdDetail> workOrdDetails = new List<WorkOrdDetail>();
            WorkOrdDetail woDetail;
            foreach (var item in morders)
            {
                //添加工单数据
                workOrd = new WorkOrdMaster();
                workOrd.Domain = "1001";
                workOrd.OrdDate = item.moentry_sys_stime;
                workOrd.ReleaseDate = Convert.ToDateTime(item.moentry_sys_stime.GetValueOrDefault().ToString("u"));
                workOrd.WorkOrd = item.morder_no;
                workOrd.ItemNum = item.product_code;//物料编码
                workOrd.QtyOrded = item.need_number.GetValueOrDefault();
                workOrd.RoutingCode = item.product_code;
                workOrd.Period = 1;
                workOrd.Priority = item.urgent;
                workOrd.Status = " ";
                workOrd.IsActive = true;
                workOrd.IsConfirm = true;
                workOrds.Add(workOrd);
                
                //添加工单工艺路线数据
                var curRoutings = allRoutings.Where(p => p.RoutingCode == item.product_code).ToList();
                foreach (var dtl in curRoutings)
                {
                    woRouting = new WorkOrdRouting();
                    woRouting.Domain = "1001";
                    woRouting.Descr = dtl.Descr;
                    woRouting.MilestoneOp = dtl.MilestoneOp;
                    woRouting.WorkOrd = item.morder_no;
                    woRouting.OP = dtl.Op;
                    woRouting.ParentOp = dtl.ParentOp;
                    woRouting.RunTime = dtl.RunTime;
                    woRouting.ItemNum = item.product_code;
                    woRouting.QtyOrded = item.need_number.GetValueOrDefault();
                    woRouting.OverlapUnits = dtl.OverlapUnits;
                    woRouting.Status = "";
                    woRouting.IsActive = true;
                    workOrdRoutings.Add(woRouting);
                }

                //添加工单物料数据
                var curStructures = productStructures.Where(p => p.ParentItem == item.product_code).ToList();
                foreach (var structure in curStructures)
                {
                    //添加工单的物料信息
                    woDetail = new WorkOrdDetail();
                    woDetail.Domain = "1001";
                    woDetail.WorkOrd = item.morder_no;
                    woDetail.Op = structure.Op;
                    woDetail.ItemNum = structure.ComponentItem;
                    woDetail.QtyRequired = item.need_number.GetValueOrDefault() * structure.Qty;
                    woDetail.QtyPosted = 0m;
                    woDetail.QtyReturned = 0m;
                    woDetail.Status = "";
                    woDetail.IsActive = true;
                    workOrdDetails.Add(woDetail);
                }
            }
            _workOrdMaster.Insert(workOrds);
            _workOrdRouting.Insert(workOrdRoutings);
            _workOrdDetail.Insert(workOrdDetails);
        }

        /// <summary>
        /// 获取标准Bom数据--TODO:存在循环查询数据库问题，后续调整
        /// </summary>
        /// <param name="itenNums">产品物料编码</param>
        /// <returns></returns>
        public List<ProductStructureMaster> GetProductStructure(List<string> itenNums)
        {
            List<ProductStructureMaster> rtnStructures = new List<ProductStructureMaster>();
            //根据itemNum获取bom数据
            var productStructures = _productStructureMaster.Select(p => itenNums.Contains(p.ParentItem) && p.Domain == "1001" && p.IsActive);
            //添加非虚拟件
            rtnStructures.AddRange(productStructures.Where(p => p.StructureType.ToUpper() != "X").ToList());
            foreach (var item in itenNums)
            {
                //获取当前产品的虚拟件
                var curPhantoms = productStructures.Where(p => p.ParentItem == item && p.StructureType.ToUpper() == "X").ToList();
                if (curPhantoms.Count() == 0)
                {
                    continue;
                }
                //递归获取所有虚拟件对应的子物料
                RecursionProductStructure(item, curPhantoms, rtnStructures);
            }
            return rtnStructures;
        }

        /// <summary>
        /// 递归获取虚拟件的子物料
        /// </summary>
        /// <param name="parentItem">产品的物料编码</param>
        /// <param name="structures">当前产品的虚拟件</param>
        /// <param name="rtnStructures"></param>
        public void RecursionProductStructure(string parentItem, List<ProductStructureMaster> structures, List<ProductStructureMaster> rtnStructures)
        {
            //获取虚拟件的子物料
            List<ProductStructureMaster> chdStructures = _productStructureMaster.Select(p => structures.Select(m => m.ComponentItem).Contains(p.ParentItem) && p.Domain == "1001" && p.IsActive);
            //非虚拟件
            var notPhantoms = chdStructures.Where(p => p.StructureType.ToUpper() != "X").ToList();
            //存在非虚拟件
            if (notPhantoms.Count() > 0)
            {
                notPhantoms.ForEach(p =>
                {
                    p.ParentItem = parentItem;
                });
                rtnStructures.AddRange(notPhantoms);
            }
            //虚拟件
            var phantoms = chdStructures.Where(p => p.StructureType.ToUpper() == "X").ToList();
            if (phantoms.Count() > 0)
            {
                //递归
                RecursionProductStructure(parentItem, phantoms, rtnStructures);
            }
        }

        /// <summary>
        /// 计算订单行的系统建议交期
        /// </summary>
        /// <param name="sentrys"></param>
        /// <param name="kittingTimes"></param>
        public async void CalcSuggestDate(List<crm_seorderentry> sentrys, List<KittingTimeDto> kittingTimes) 
        {
            //获取排产记录
            List<string> itemNums = sentrys.Select(p=>p.item_number).Distinct().ToList();
            DateTime eralist = kittingTimes.Min(p => p.kitting_time).Date;
            List<PeriodSequenceDet> periodSequences = _periodSequenceDet.Select(p => itemNums.Contains(p.ItemNum) && p.PlanDate >= eralist).ToList();

            //资源检查添加产线工序等数据
            _productExamineAppService.prodLines = prodLines;
            _productExamineAppService.routingOps = routingOps;
            _productExamineAppService.calendarWorks = calendarWorks;
            _productExamineAppService.qualityLineWorks = qualityLineWorks;
            _productExamineAppService.holidays = holidays;
            _productExamineAppService.periodSequences = periodSequences;
            if (sentrys.Count() == 0)
            {
                return;
            }
            sentrys = _productExamineAppService.CalcSuggestTime(sentrys, kittingTimes);
            await _mysql_crm_seorderentry.UpdateManyAsync(sentrys);
        }
    }
}