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

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Domain.Repositories;
using Business.Models;
using Microsoft.AspNetCore.Authorization;
using Business.Permissions;
using XCZ;
using Business.ResourceExamineManagement.Dto;
using Bussiness.Model.MES.IC;
using AutoMapper.Internal.Mappers;
using Bussiness.Model.Tech;
using Bussiness.Model.Production;
using Business.Core.MongoDBHelper;
using Business.Core.Utilities;
using Hangfire.Storage.Monitoring;
using Business.BookManagement.Dto;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Application.Services;
using ZstdSharp.Unsafe;
using System.Transactions;
using NUglify.JavaScript.Syntax;
using System.Linq.Expressions;
using XCZ.Extensions;
using System.ComponentModel;
using System.Reflection.Emit;
using NUglify.Helpers;
using Microsoft.AspNetCore.SignalR.Protocol;
using System.ComponentModel.Design;
using Volo.Abp.Validation.StringValues;
using System.Runtime.CompilerServices;
using MongoDB.Driver;
using Volo.Abp.Validation.Localization;
using Hangfire.Annotations;
using System.Globalization;
using MongoDB.Driver.Linq;
using Bussiness.Model.SRM;
using System.ComponentModel.DataAnnotations;
using Bussiness.Model.Sale;
using Amazon.Runtime.Internal.Transform;
using System.IO.Compression;
using System.Collections;
using System.Data.SqlTypes;
using Microsoft.EntityFrameworkCore.Diagnostics;
using Hangfire.Server;
using WkHtmlToPdfDotNet;
using Microsoft.EntityFrameworkCore.Migrations.Operations;
using Microsoft.AspNetCore.SignalR;
using System.Diagnostics;
using Newtonsoft.Json;

namespace Business.ResourceExamineManagement
{
    /// <summary>
    /// 资源检查
    /// </summary>
    //[Authorize(BusinessPermissions.ResourceExamine.Default)]
    public class ResourceExamineAppService : ApplicationService, IResourceExamineAppService
    {
        #region 服务
        SnowFlake help = new SnowFlake();

        /// <summary>
        /// 工艺路径
        /// </summary>
        private readonly IMongoDB<mes_technique> _mes_technique;
        private IRepository<mes_technique, long> _mysql_mes_technique;

        /// <summary>
        /// 工序
        /// </summary>
        private readonly IMongoDB<mes_process> _mes_process;
        private IRepository<mes_process, long> _mysql_mes_process;

        /// <summary>
        /// 工艺关联工序
        /// </summary>
        private readonly IMongoDB<mes_tech_process> _mes_tech_process;
        private IRepository<mes_tech_process, long> _mysql_mes_tech_process;

        /// <summary>
        /// 工作日历
        /// </summary>
        private readonly IMongoDB<mes_work_calendar> _mes_work_calendar;

        /// <summary>
        /// 工作日历明细
        /// </summary>
        private readonly IMongoDB<mes_work_calendar_list> _mes_work_calendar_list;

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

        /// <summary>
        /// 排程占用记录
        /// </summary>
        private readonly IMongoDB<mes_schedule_occupy> _mes_schedule_occupy;

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

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

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

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

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

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

        /// <summary>
        /// 物料采购报价单
        /// </summary>
        private readonly IMongoDB<ic_item_pur> _ic_item_pur;
        private IRepository<ic_item_pur, long> _mysql_ic_item_pur;

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

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

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

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

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

        /// <summary>
        /// 物料质检表
        /// </summary>
        private readonly IMongoDB<ic_check> _ic_check;
        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<ic_substitute> _ic_substitute;
        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<ic_substitute_all> _ic_substitute_all;
        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<ic_substitute_all_dtl> _ic_substitute_all_dtl;

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

        /// <summary>
        /// 在制工单占用记录表
        /// </summary>
        private readonly IMongoDB<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;
        private readonly IMongoDB<crm_seorder> _crm_seorder;
        /// <summary>
        /// 销售订单明细
        /// </summary>
        private readonly IRepository<crm_seorderentry, long> _mysql_crm_seorderentry;
        private readonly IMongoDB<crm_seorderentry> _crm_seorderentry;

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

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

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="icitem"></param>
        /// <param name="icbom"></param>
        public ResourceExamineAppService(
            IMongoDB<mes_technique> mes_technique,
            IMongoDB<mes_process> mes_process,
            IMongoDB<mes_tech_process> mes_tech_process,
            IMongoDB<mes_tech_proc_workshop> mes_tech_proc_workshop,
            IMongoDB<ic_item> ic_item,
            IMongoDB<ic_bom> ic_bom,
            IMongoDB<ic_bom_child> ic_bom_child,
            IMongoDB<ic_item_stock> ic_item_stock,
            IMongoDB<ic_check> ic_check,
            IMongoDB<ic_factory_details> ic_factory_details,
            IMongoDB<mes_oorder> mes_oorder,
            IMongoDB<srm_pr_main> srm_pr_main,
            IMongoDB<srm_po_main> srm_po_main,
            IMongoDB<srm_po_list> srm_po_list,
            IMongoDB<crm_seorder> crm_seorder,
            IMongoDB<crm_seorderentry> crm_seorderentry,
            IMongoDB<srm_po_occupy> srm_po_occupy,
            IMongoDB<ic_item_pur> ic_item_pur,
            IMongoDB<ic_plan> ic_plan,
            IMongoDB<ic_substitute> ic_substitute,
            IMongoDB<ic_substitute_all> ic_substitute_all,
            IMongoDB<ic_substitute_all_dtl> ic_substitute_all_dtl,
            IMongoDB<mes_morder> mes_morder,
            IMongoDB<mes_moentry> mes_moentry,
            IMongoDB<mes_mooccupy> mes_mooccupy,
            IMongoDB<ic_item_stockoccupy> ic_item_stockoccupy,
            IRepository<ic_item, long> mysql_ic_item,
            IRepository<ic_bom, long> mysql_ic_bom,
            IRepository<ic_bom_child, long> mysql_ic_bom_child,
            IRepository<mes_technique, long> mysql_mes_technique,
            IRepository<crm_seorder, long> mysql_crm_seorder,
            IRepository<crm_seorderentry, long> mysql_crm_seorderentry,
            IRepository<ic_item_stock, long> mysql_ic_item_stock,
            IRepository<ic_factory_details, long> mysql_ic_factory_details,
            IRepository<mes_oorder, long> mysql_mes_oorder,
            IRepository<srm_pr_main, long> mysql_srm_pr_main,
            IRepository<mes_mooccupy, long> mysql_mes_mooccupy,
            IRepository<mes_morder, long> mysql_mes_morder,
            IRepository<mes_moentry, long> mysql_mes_moentry,
            IRepository<mes_process, long> mysql_mes_process,
            IRepository<mes_tech_process, long> mysql_mes_tech_process,
            IRepository<srm_po_main, long> mysql_srm_po_main,
            IRepository<srm_po_list, long> mysql_srm_po_list,
            IRepository<srm_po_occupy, long> mysql_srm_po_occupy,
            IRepository<ic_item_pur, long> mysql_ic_item_pur,
            IRepository<ic_plan, long> mysql_ic_plan
            )
        {
            _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;
            _crm_seorder = crm_seorder;
            _crm_seorderentry = crm_seorderentry;
            _srm_po_occupy = srm_po_occupy;
            _ic_item_pur = ic_item_pur;
            _ic_plan = ic_plan;
            _ic_substitute = ic_substitute;
            _ic_substitute_all = ic_substitute_all;
            _ic_substitute_all_dtl = ic_substitute_all_dtl;
            _mes_morder = mes_morder;
            _mes_moentry = mes_moentry;
            _mes_mooccupy = mes_mooccupy;
            _ic_item_stockoccupy = ic_item_stockoccupy;
            _mysql_ic_item = mysql_ic_item;
            _mysql_ic_bom = mysql_ic_bom;
            _mysql_ic_bom_child = mysql_ic_bom_child;
            _mysql_crm_seorder = mysql_crm_seorder;
            _mysql_crm_seorderentry = mysql_crm_seorderentry;
            _mysql_mes_technique = mysql_mes_technique;
            _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_mes_process = mysql_mes_process;
            _mysql_mes_tech_process = mysql_mes_tech_process;
            _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_ic_item_pur = mysql_ic_item_pur;
            _mysql_ic_plan = mysql_ic_plan;
        }
        #endregion

        /// <summary>
        /// mongoDB示例方法，后期删除
        /// </summary>
        /// <returns></returns>
        public async Task test()
        {
            ////多条插入
            //List<mes_technique> infos = new List<mes_technique>();
            //mes_technique info;
            //for (int i = 0; i < 3; i++)
            //{
            //    info = new mes_technique();
            //    info.GenerateNewId();
            //    info.tech_name = "多条" + i;
            //    info.level = i;
            //    infos.Add(info);
            //}
            //await _mes_technique.InsertMany(infos);

            //var info2 = _mes_technique.GetAll().Result;
            //var a = new PschedDto();
            //a.count = info2.Count;

            ////获取数据
            //var info1 = await _mes_technique.GetOneByID((long)1732029975067480064);

            ////更新数据
            //info1.tech_name = "更新***";
            //var rlt = await _mes_technique.UpdateOne(info1, info1.Id);

            ////根据条件查询数据
            //Expression<Func<mes_technique, bool>> filter = x => x.Id == (long)1732376973889097728 && x.tech_name == "多条0";
            //var info3 = await _mes_technique.GetManyByCondition(filter);

            ////删除数据
            ////根据id删除数据
            ////await _ic_item_stock.DeleteByIds(136123);

            ////根据id删除表数据
            //List<long> aa = new List<long>();
            //aa.Add(136131);
            //aa.Add(136132);
            //aa.Add(136133);
            //FilterDefinition<ic_item_stock> filter = Builders<ic_item_stock>.Filter.In(s => s.icitem_id, aa);
            //await _ic_item_stock.Delete(filter);

            //根据条件删除数据
            //await _ic_item_stock.Delete(p=>p.icitem_name == "test");

            //await _ic_item_stock.DeleteByIds(aa);
            //await _ic_item_stock.DeleteAll();
        }

        /// <summary>
        /// 资源检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<string> ReceiveResult(SeorderentryDto input)
        {
            //资源检查入参全局变量赋值
            param.sorderId = input.sorderId;
            param.tenantId = input.tenantId;
            param.factoryId = input.factoryId;
            
            //资源检查结果
            PschedDto rtn = new PschedDto();
            rtn.sorderid = input.sorderId;
            //资源检查明细list
            List<ExamineResult> examines = new List<ExamineResult>();
            ExamineResult dtl;

            //生成当前计算bangid
            SnowFlake snow = new SnowFlake();
            long bangid = snow.NextId();

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

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

            //通过订单行获取物料BOM数据
            //FilterDefinition<ic_bom> filter = Builders<ic_bom>.Filter.In(s => s.bom_number, sentrys.Select(m => m.bom_number).ToList());
            //List<ic_bom> boms = _ic_bom.GetManyByIds(filter).Result.Where(p => p.factory_id == input.factoryId && p.tenant_id == input.tenantId && !p.IsDeleted).ToList();
            List<ic_bom> boms = _ic_bom.Find(p=>sentrys.Select(m=>m.bom_number).Contains(p.bom_number) && p.factory_id == input.factoryId && p.tenant_id == input.tenantId && !p.IsDeleted).Result.ToList();
            //通过物料id获取产品提前期
            List<ICItemLeadTimeDto> leadTimes = GetLeadTime(boms.Select(p => p.icitem_id).ToList(), input.tenantId, input.factoryId);

            //物料bom
            List<ic_bom> bomlist = new List<ic_bom>();
            //物料bom明细
            List<ic_bom_child> bomchildlist = new List<ic_bom_child>();
            //获取物料bom，物料bom明细
            GetIcBomData(boms, bomlist, bomchildlist);
            
            //获取物料数据
            List<long> itemIds = bomlist.Select(p => p.icitem_id).ToList();
            itemIds.AddRange(bomchildlist.Select(p => p.icitem_id).ToList());
            List<ic_item> icitemlist = _ic_item.GetManyByCondition(p => itemIds.Contains(p.Id) && !p.IsDeleted).Result;

            foreach (var item in sentrys)
            {
                //工单资源检查信息
                dtl = new ExamineResult();
                dtl.sentry_id = item.Id;
                //TODO:最早开始时间默认3天后(后期调整)
                dtl.earliest_times = DateTime.Now.Date.AddDays(3);

                //获取当前物料bom数据
                var childBom = boms.Where(p => p.bom_number == item.bom_number).FirstOrDefault();
                //bom层级组装
                var getBomList = BomPretreatment(item.Id, childBom.Id, item.qty.GetInt(), bomlist, bomchildlist, icitemlist);
                //bom替代关系组装
                BomSubstitute(getBomList, bomlist, bomchildlist, icitemlist);
                //库存初始化
                BomStock(getBomList, bangid, input.factoryId);
                //计算
                calcTest(getBomList, bangid, item.Id, item.qty.Value, input, item.plan_date);

                //TODO:最晚开始时间
                var curFacDtl = leadTimes.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()));
                //物料齐套时间
                dtl.kitting_times = getBomList.Where(p => p.is_use).OrderByDescending(m => m.kitting_time).First().kitting_time.GetValueOrDefault();
                //替代关系展开list
                dtl.substitutes = getBomList;
                //添加订单行开工信息
                examines.Add(dtl);
                //生成工单 TODO：0=产品数量
                //GenerateMorder(o, 0);
            }
            //订单行资源检查明细list
            rtn.examines = examines;
            return JsonConvert.SerializeObject(rtn);
        }

        /// <summary>
        /// 获取icbom,icbomchild数据
        /// </summary>
        /// <param name="icBoms"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        public void GetIcBomData(List<ic_bom> icBoms, List<ic_bom> bomlist, List<ic_bom_child> bomchildlist)
        {
            if (icBoms.Count() == 0)
            {
                return;
            }
            //添加物料bom数据
            bomlist.AddRange(icBoms);
            //获取物料bom明细数据
            List<ic_bom_child> childList = _ic_bom_child.GetManyByCondition(p => icBoms.Select(m=>m.Id).Contains(p.bom_id) && p.use_status == 1 && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.ToList();
            //没有明细数据,终止
            if (childList.Count == 0)
            {
                return;
            }
            bomchildlist.AddRange(childList);
            //通过物料bom明细数据反查物料bom数据
            var boms = _ic_bom.GetManyByCondition(p => childList.Select(m=>m.icitem_id).ToList().Contains(p.icitem_id) && p.fse_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>
        /// <returns></returns>
        public long Save(long tenantId, long factoryId)
        {
            //销售订单
            crm_seorder crm_Seorder = new crm_seorder()
            {
                IsDeleted = false,
                bill_no = "SO201900000020",
                order_type = 1,
                trade_type = 1,
                sale_style = 1,
                custom_id = 1001,
                custom_name = "温州正泰电器科技有限公司",
                custom_no = "01.0098",
                date = DateTime.Now.Date,
                currency = 1,
                exchange_rate = 1,
                biller = "张晓延",
                emp_no = "8604",
                emp_name = "王劲松",
                auditor = "邹晓燕",
                audit_date = DateTime.Now.Date,
                status = 1,
                closed = true,
                op_time = DateTime.Now.Date,
                tenant_id = tenantId,
                factory_id = factoryId,
                org_id = tenantId
            };
            crm_Seorder.GenerateNewId();
            crm_seorderentry crm_Seorderentry = new crm_seorderentry()
            {
                IsDeleted = false,
                seorder_id = crm_Seorder.Id,
                bill_no = "SO201900000020",
                entry_seq = 1,
                map_name = "自动转换开关电器",
                map_number = "L6.733036.5",
                item_number = "9.1.03.01.0541",
                item_name = "自动转换开关电器",
                fms_number = "988123",
                specification = "FDQ3-RMQ6-63/4JC1R_基本型",
                bom_number = "BOM00042070",
                unit = "台",
                qty = 1000,
                price = 100,
                tax_price = 0,
                amount = 0,
                tax_rate = 13,
                discount_amount = 0,
                discount_rate = 0,
                aux_price_discount = 70,
                total_amount = 0,
                plan_date = DateTime.Parse("2023-04-29 00:00:00"),
                planner_name = "钱萍萍",
                planner_no = "9022",
                state = true,
                rstate = 0,
                is_checked = true,
                deliver_count = 0,
                deliver_notice_count = 0,
                tenant_id = tenantId,
                factory_id = factoryId,
                org_id = tenantId,
            };
            crm_Seorderentry.GenerateNewId();

            _mysql_crm_seorder.InsertAsync(crm_Seorder);
            _mysql_crm_seorderentry.InsertAsync(crm_Seorderentry);

            return crm_Seorderentry.Id;
        }

        /// <summary>
        /// 数据库快照
        /// </summary>
        /// <returns></returns>
        public async Task SyncData(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; });
                //插入数据
                await _ic_item_stock.InsertMany(icitemStokc);
            }
            //在制工单占用记录表
            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; });
                await _mes_mooccupy.InsertMany(mes_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; });
                await _mes_morder.InsertMany(mes_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; });
                await _mes_moentry.InsertMany(mes_moentry);
            }

            //TODO:要不要根据某些条件只同步有效的数据
            //销售订单
            var crm_seorder = _mysql_crm_seorder.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (crm_seorder.Count > 0)
            {
                crm_seorder.ForEach(item => { item.bang_id = bangid; });
                await _crm_seorder.InsertMany(crm_seorder);
            }

            //销售订单明细
            var crm_seorderentry = _mysql_crm_seorderentry.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (crm_seorderentry.Count > 0)
            {
                crm_seorderentry.ForEach(item => { item.bang_id = bangid; });
                await _crm_seorderentry.InsertMany(crm_seorderentry);
            }

            //采购订单
            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; });
                await _srm_po_main.InsertMany(srm_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; });
                await _srm_po_list.InsertMany(srm_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; });
                await _srm_po_occupy.InsertMany(srm_po_occupy);
            }

            //工厂物料明细表
            var ic_factory_details = _mysql_ic_factory_details.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (ic_factory_details.Count > 0)
            {
                ic_factory_details.ForEach(item => { item.bang_id = bangid; });
                await _ic_factory_details.InsertMany(ic_factory_details);
            }

            //物料采购计划表
            var ic_plan = _mysql_ic_plan.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (ic_plan.Count > 0)
            {
                ic_plan.ForEach(item => { item.bang_id = bangid; });
                await _ic_plan.InsertMany(ic_plan);
            }

            //物料采购报价单
            var ic_item_pur = _mysql_ic_item_pur.GetListAsync(x => x.tenant_id == tenantId && x.factory_id == factoryId).Result;
            if (ic_item_pur.Count > 0)
            {
                ic_item_pur.ForEach(item => { item.bang_id = bangid; });
                await _ic_item_pur.InsertMany(ic_item_pur);
            }
        }

        /// <summary>
        /// 产能计算
        /// </summary>
        /// <param name="tech_id">工艺路径主键</param>
        /// <param name="packages">需要生产产品件数</param>
        /// <returns>生产时长</returns>
        public async Task<decimal> ProductiveExamine(string bom_number, int packages)
        {
            if (packages <= 0)
            {
                throw new NotImplementedException("产能计算参数有误！");
            }
            #region 1、数据准备
            //1.1、获取工艺路径数据
            mes_technique tech = _mes_technique.Find(p => p.bom == bom_number && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted).Result.FirstOrDefault();
            if (tech == null)
            {
                throw new NotImplementedException("请先配置工艺路径！");
            }

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

            //1.3、获取当前工艺路径下的工序数据
            //FilterDefinition<mes_process> filter = Builders<mes_process>.Filter.In(s => s.Id, tech_Processes.Select(m => m.proc_id).ToList());
            //List<mes_process> process = await _mes_process.GetManyByIds(filter);
            List<long> procIds = tech_Processes.Select(m => m.proc_id.Value).ToList();
            List<mes_process> process = await _mes_process.GetManyByCondition(p => procIds.Contains(p.Id) && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted);

            //1.3、获取工艺工序关联工位信息
            List<long> techProcIds = tech_Processes.Select(m => m.Id).ToList();
            List<mes_tech_proc_workshop> tech_Proc_Workshops = await _mes_tech_proc_workshop.GetManyByCondition(p => techProcIds.Contains(p.tech_proc_id.Value) && p.tenant_id == param.tenantId && p.factory_id == param.factoryId && !p.IsDeleted);
            #endregion

            #region 计算产能，得到耗时
            decimal sumTimes = 0.00m;//总耗时(分钟)
            //工序需要等待时间记录
            List<StartTimeDto> starts = new List<StartTimeDto>();
            //1、获取工艺路径下的第一层级工序
            List<mes_tech_process> fistChilds = tech_Processes.Where(p => p.parentprocid == tech.Id).ToList();
            if (fistChilds.Count == 0)
            {
                throw new NotImplementedException("当前工艺路径没有配置工序，请调整！");
            }
            List<mes_tech_process> sortChilds = new List<mes_tech_process>();
            //添加最后一个工序
            var last = fistChilds.First(p => p.nextprocid == null);
            sortChilds.Add(last);
            SortProcess(fistChilds, last.Id, sortChilds);

            decimal curTakeTime = 0.00m;//当前工序耗时(分钟)
            //添加第一个工序需要等待时间记录
            StartTimeDto dto;
            foreach (var chd in fistChilds)
            {
                dto = new StartTimeDto();
                if (chd.nextprocid == null)//最后一个工序
                {
                    //计算最后一个工序耗时
                    curTakeTime = CalcTakeTime(chd, packages);
                }
                else
                {
                    curTakeTime = CalcTakeTime(chd, chd.lq.Value);
                }
                sumTimes += curTakeTime;
                //添加耗时记录
                dto.tech_id = tech.Id;
                dto.proc_id = chd.proc_id.Value;
                dto.nextproc_id = chd.nextprocid;
                dto.wait_time = curTakeTime;
                starts.Add(dto);
            }
            #endregion

            return sumTimes;
        }

        /// <summary>
        /// 递归:工序按照先后顺序排序-暂时不考虑两个分支合并到一个分支的情况
        /// </summary>
        /// <param name="Processes"></param>
        /// <param name="processId"></param>
        /// <param name="sortProcesses"></param>
        private void SortProcess(List<mes_tech_process> Processes, long processId, List<mes_tech_process> sortProcesses)
        {
            var curProcess = Processes.Where(p => p.nextprocid == processId).FirstOrDefault();
            if (curProcess != null)
            {
                sortProcesses.AddFirst(curProcess);
                SortProcess(Processes, curProcess.Id, sortProcesses);
            }
        }

        /// <summary>
        /// 计算当前工序前置准备时间
        /// </summary>
        /// <param name="proc"></param>
        /// <param name="quantity">LeadQuantity to Start Next</param>
        /// <returns></returns>
        private decimal CalcTakeTime(mes_tech_process proc, decimal quantity)
        {
            decimal takeTime = 0.00m;//当前工序前置准备时间(分钟)
            if (proc.wctype == 1)//人工型:数量/uph(一小时生产数量)*60(小时转换为分钟)/wsinuse(工位数)
            {
                takeTime = quantity / proc.uph.Value * 60 / proc.wsinuse.Value;
                return takeTime;
            }
            else if (proc.wctype == 2)//流水线型:数量*ct(生产一件所需时间)/wsinuse(工位数)
            {
                takeTime = quantity * proc.ct.Value / proc.wsinuse.Value;
                return takeTime;
            }
            else if (proc.wctype == 3)//设备型:向上取整(数量/一次可加工数量/wsinuse(工位数))*ct(老化一次所需时间)
            {
                takeTime = Math.Ceiling(quantity / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
                return takeTime;
            }
            return takeTime;
        }

        /// <summary>
        /// 生成工单
        /// </summary>
        /// <param name="BomNumber">Bom编码</param>
        /// <param name="Quantity">需要数量</param>
        /// <param name="DeliverDate">交付日期</param>
        /// <param name="seorderentry_id">销售订单子表ID</param>
        /// <returns></returns>
        public void GenerateMorder(crm_seorderentry seorderentry, decimal? Quantity)
        {
            //1.库存、在制工单检查完成后 当前BOM需要自制时 产生工单。

            //2.每一个销售订单行对应一个工单。
            //查询销售订单子表数据
            //var seorderentry = await _mysql_crm_seorderentry.FindAsync(x => x.Id == seorderentry_id);
            //获取销售订单信息
            var seorder = _mysql_crm_seorder.FindAsync(x => x.Id == seorderentry.seorder_id).Result;
            //物料BOM
            // var ic_bom = _ic_bom.GetManyByCondition(x => x.bom_number == seorderentry.bom_number && x.factory_id == seorderentry.factory_id).Result.FirstOrDefault();

            var ic_bom = _ic_bom.GetManyByCondition(x => x.bom_number == seorderentry.bom_number).Result.FirstOrDefault();

            var Number = seorderentry.qty - Quantity;

            mes_morder mes_Morder = new mes_morder();
            mes_Morder.GenerateNewId();
            mes_Morder.morder_type = "销售工单";
            //mes_Morder.morder_icitem_type
            mes_Morder.work_order_type = "常规工单";
            mes_Morder.morder_state = "初始";
            mes_Morder.morder_no = string.Format("VMO{0}", DateTime.Now.ToString("yyyyMMddhhmmss"));//测试编码
            mes_Morder.fms_number = seorderentry.fms_number;
            mes_Morder.bom_number = seorderentry.bom_number;
            mes_Morder.fmodel = seorderentry.specification;
            //最早的开工时间3天后、 最晚时间为订单承诺时间-采购提前期-质检提前期-入库提前期-发料提前期 =最晚开工时间  最早或最晚为系统建议开工日期
            //根绝系统配置参数 取最早或者最晚开始日期
            var StartDate = DateTime.Now.Date.AddDays(3);
            mes_Morder.moentry_sys_stime = StartDate;
            var ProductiveDate = ProductiveExamine(ic_bom.bom_number, (int)(Number.Value));
            //系统建议完工日期为 开工日期+产能检查时间=完工日期
            var Day = ProductiveDate.Result / (60 * 10); //返回的分钟除以十个小时得出工作天数；
            mes_Morder.moentry_sys_etime = StartDate.AddDays((double)Day);
            mes_Morder.morder_need_time = ProductiveDate.Result;
            mes_Morder.moentry_startup_status = 0;
            mes_Morder.tenant_id = seorderentry.tenant_id;
            mes_Morder.factory_id = seorderentry.factory_id;
            mes_Morder.product_code = seorderentry.item_number;
            mes_Morder.product_name = seorderentry.item_name;
            mes_Morder.project_name = seorder.project_name;
            mes_Morder.planner_num = seorderentry.planner_no;
            mes_Morder.planner_name = seorderentry.planner_name;
            mes_Morder.morder_date = DateTime.Now.Date;
            //mes_Morder.morder_fstate = "计划";
            //TODO:目前没有取值位置
            mes_Morder.moentry_prd = null;
            mes_Morder.moentry_prdname = null;
            mes_Morder.moentry_wrkc = null;
            mes_Morder.moentry_wrkcname = null;
            mes_Morder.picking_qty = 0;
            //TODO:可删除主表字段
            mes_Morder.unit = seorderentry.unit;
            mes_Morder.morder_production_number = Number;
            mes_Morder.need_number = Number;
            mes_Morder.remaining_number = 0;
            //生成工单子表数据
            mes_moentry mes_Moentry = new mes_moentry();
            mes_Moentry.GenerateNewId();
            mes_Moentry.moentry_moid = mes_Morder.Id;
            mes_Moentry.moentry_mono = mes_Morder.morder_no;
            mes_Moentry.soentry_id = seorderentry.Id;
            mes_Moentry.fbill_no = seorderentry.bill_no;
            mes_Moentry.fentry_id = seorderentry.entry_seq.Value;
            mes_Moentry.unit = seorderentry.unit;
            mes_Moentry.morder_production_number = Number;
            mes_Moentry.need_number = Number;
            mes_Moentry.remaining_number = 0;
            mes_Moentry.factory_id = seorderentry.factory_id;
            //using (TransactionScope scope = new TransactionScope())
            // {
            _mes_morder.InsertOne(mes_Morder);
            _mes_moentry.InsertOne(mes_Moentry);
            //scope.Complete();
            //}
        }
        /// <summary>
        /// 检查成品库存
        /// </summary>
        /// <param name="seorderentry_id">销售订单子表ID</param>
        /// <returns></returns>
        public async Task<bool> CheckFinishedProductInventory(long seorderentry_id)
        {
            //获取销售订单子表
            var seorderentry = await _mysql_crm_seorderentry.FindAsync(x => x.Id == seorderentry_id);
            if (string.IsNullOrEmpty(seorderentry.bom_number))
            {
                return false;
            }
            //物料BOM
            var ic_bom = _ic_bom.GetManyByCondition(x => x.bom_number == seorderentry.bom_number && x.tenant_id == seorderentry.tenant_id).Result.FirstOrDefault();
            //物料库存表
            var ic_Item_Stocks = await _ic_item_stock.GetManyByCondition(x => x.icitem_id == ic_bom.icitem_id && x.tenant_id == seorderentry.tenant_id);
            if (seorderentry.qty <= ic_Item_Stocks.Sum(x => x.sqty))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 检查在制工单
        /// </summary>
        /// <param name="bomNumber">Bom编码</param>
        /// <param name="Quantity">需要数量</param>
        /// <param name="DeliverDate">交付日期</param>
        /// <param name="seorderentry_id">销售订单子表ID</param>
        /// <returns></returns>
        public async Task<int> CheckMorder(string bomNumber, decimal? Quantity, DateTime DeliverDate, crm_seorderentry seorderentry)
        {
            if (string.IsNullOrEmpty(bomNumber) || Quantity == null)
            {
                //TODO：入参异常；
                throw new NotImplementedException("BOM编码或需求数量不能为空!");
            }
            var Number = 3; //1,满足，2数量满足，时间不满足，3不满足
            //获取销售订单信息
            //var seorder = await _crm_seorder.FindAsync(x => x.Id == OrderId);
            //var seorderentry = await _mysql_crm_seorderentry.FindAsync(x => x.Id == seorderentry_id);
            //根据Bom编码查询出对应工单并且状态不为完成、关闭，非委外工单。
            //TODO:工单类型；
            var morderList = await _mes_morder.GetManyByCondition(x => x.bom_number == bomNumber && (x.morder_state != "完成" || x.morder_state != "关闭"
            && x.morder_icitem_type != "相关委外工单") && !x.IsDeleted && x.tenant_id == seorderentry.tenant_id);

            //获取物料详情
            var ic_item = _ic_item.GetManyByCondition(x => x.number == seorderentry.item_number && x.tenant_id == seorderentry.tenant_id).Result.FirstOrDefault();

            //工单已被占用后要与占用表关联查询...减去占用量后 剩下生产数量可供下个销售工单使用。
            var mes_mooccupyList = await _mes_mooccupy.GetManyByCondition(x => x.moo_state == 1 && !x.IsDeleted && x.tenant_id == seorderentry.tenant_id);

            //首先满足需求数量工单其次判断是否满足交付日期、当数量不满足时继续查找最早交付日期订单 工单数量累加。
            //当前工单计划日期-1天 小于交付日期 && 计算生产数量-入库数据并且大于需求产品数量。
            var morderDataList = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) < DeliverDate &&
            (x.morder_production_number - x.inventory_number) > Quantity).ToList();


            if (morderDataList.Count > 0)
            {
                //存在此数据满足当前BOM交付找到最早日期工单，则返回无需后续继续检查。
                var morder = morderDataList.OrderByDescending(x => x.planner_end_date).FirstOrDefault();
                var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == morder.Id).ToList();
                var mes_Mooccupy = GetMooccupies(seorderentry, ic_item, morder, mooccupies);
                await _mes_mooccupy.InsertOne(mes_Mooccupy);
                Number = 1;
            }
            else
            {
                // 寻找最早日期工单 &&  计算生产数量-入库数据并且大于需求产品数量后累加直到满足需求产品数量
                var morderListData = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();
                List<mes_mooccupy> mes_Mooccupies = new List<mes_mooccupy>();
                decimal? number = Quantity;
                foreach (var item in morderListData)
                {
                    //查询出工单已占用总数量
                    var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();
                    var mes_Mooccupy = GetMooccupies(seorderentry, ic_item, item, mooccupies);
                    mes_Mooccupies.Add(mes_Mooccupy);
                    //需求数量-占用量后小于或等于0 停止循环占用工单
                    if (number - mes_Mooccupy.moo_qty <= 0)
                    {
                        break;
                    }
                }
                var morderDatas = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) > DeliverDate &&
          (x.morder_production_number - x.inventory_number) > Quantity).ToList();
                if (number > 0)
                {
                    Number = 3;
                }
                if (morderDatas.Count > 0)
                {
                    Number = 2;
                }
                else
                {
                    Number = 1;
                }
            }
            return Number;
        }
        /// <summary>
        /// 拼接工单占用表
        /// </summary>
        /// <param name="seorderentry">销售订单子表</param>
        /// <param name="mysql_ic_item">物料详情表</param>
        /// <param name="item">工单表</param>
        /// <param name="mes_mooccupy">占用工单表</param>
        /// <returns></returns>
        public mes_mooccupy GetMooccupies(crm_seorderentry seorderentry, ic_item ic_item, mes_morder item, List<mes_mooccupy> mes_mooccupy)
        {
            decimal? Sumqty = 0;
            if (mes_mooccupy.Count > 0)
            {
                Sumqty = mes_mooccupy.Sum(x => x.moo_qty);
            }
            //生成mes_mooccupy工单占用表数据，代表多个工单被某个销售订单已占用。 
            mes_mooccupy mes_Mooccupy = new mes_mooccupy();
            mes_Mooccupy.GenerateNewId();
            mes_Mooccupy.moo_id_type = "分配";
            mes_Mooccupy.moo_id_billid = seorderentry.seorder_id;//销售订单ID
            mes_Mooccupy.fbill_no = seorderentry.bill_no;//销售订单号
            mes_Mooccupy.fentry_id = seorderentry.entry_seq.Value;//销售订单行
            mes_Mooccupy.fitem_name = ic_item.name;//物料名称
            mes_Mooccupy.fitem_number = ic_item.number;
            mes_Mooccupy.fmodel = ic_item.model;//规格型号
            mes_Mooccupy.moo_moid = item.Id;
            mes_Mooccupy.moo_mo = item.morder_no;
            //占用量=生产计划数量-入库数量-已被占用数量
            mes_Mooccupy.moo_qty = item.morder_production_number - item.inventory_number - Sumqty;
            mes_Mooccupy.moo_stime = DateTime.Now.Date;
            mes_Mooccupy.moo_etime = DateTime.Now;//日期来源需确定
            mes_Mooccupy.moo_state = 1;
            mes_Mooccupy.moo_cbr = string.Empty;
            //mes_Mooccupy.moo_ctime = ;
            mes_Mooccupy.moo_creason = string.Empty;
            mes_Mooccupy.tenant_id = seorderentry.tenant_id;//取销售子表企业ID
            mes_Mooccupy.factory_id = seorderentry.factory_id;
            mes_Mooccupy.factory_id = seorderentry.factory_id;
            return mes_Mooccupy;
        }
        /// <summary>
        /// BOM预处理
        /// </summary>
        /// <param name="orderid"></param>
        /// <param name="BomId"></param>
        /// <param name="Quantity"></param>
        public List<BomChildExamineDto> BomPretreatment(long? orderid, long? BomId, int Quantity, List<ic_bom> bomlist, List<ic_bom_child> bomchildlist, List<ic_item> icitemlist)
        {
            if (orderid == null)
            {
                //throw new bu
            }
            if (BomId == null)
            {
                //throw new bu
            }
            List<BomChildExamineDto> returnlist = new List<BomChildExamineDto>();
            //var query = (await _ic_bom.GetQueryableAsync()).WhereIf(true, a => a.bom_id == BomId).ToList();
            
            var bom = bomlist.Find(s => s.Id == BomId);
            if (bom == null)
            {
                return returnlist;
            }

            var dto = new BomChildExamineDto();
            dto.item_id = bom.icitem_id;
            dto.bom_id = BomId.Value;
            dto.level = 1;
            dto.id = help.NextId();
            dto.parent_id = help.NextId();
            dto.qty = 1;
            dto.num = "1";
            dto.isbom = 1;
            dto.is_replace = 0;
            dto.haveicsubs = 0;
            dto.substitute_code = "";
            dto.icitem_ids = "";
            int type = 0;
            GetBomList(bomlist, bomchildlist, icitemlist, dto, returnlist, type);
            return returnlist;
        }

        /// <summary>
        /// BOM预处理层级组装
        /// </summary>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        /// <param name="icitemlist"></param>
        /// <param name="dto"></param>
        /// <param name="returnlist"></param>
        public void GetBomList(List<ic_bom> bomlist, List<ic_bom_child> bomchildlist, List<ic_item> icitemlist, BomChildExamineDto dto, List<BomChildExamineDto> returnlist, int type)
        {
            int level = dto.level + 1;//初始化定义level层级

            var bom = bomlist.Where(s => s.Id == dto.bom_id).FirstOrDefault();
            ic_item item = new ic_item();
            if (bom != null)
            {
                item = icitemlist.Where(a => a.Id == bom.icitem_id).FirstOrDefault();
            }
            else
            {
                item = icitemlist.Where(a => a.Id == dto.item_id).FirstOrDefault();
            }
            if (item == null)
            {
                return;
            }
            dto.item_id = item.Id;
            dto.item_name = bom.item_name;
            dto.item_code = bom.item_number;
            dto.model = item.model;
            dto.unit = bom.unit;
            dto.erp_cls = item.erp_cls;
            dto.erp_cls_name = item.erp_cls_name;
            dto.type = type;

            //var bdto = ObjectMapper.Map<ic_bom,BomChildExamineDto>(bom);
            returnlist.Add(dto);
            var childlist = bomchildlist.WhereIf(true, a => a.bom_id == bom.Id).ToList();

            int idx = 1;
            foreach (var c in childlist)
            {
                string childNum = dto.num + "." + idx.ToString();
                var icitem = icitemlist.WhereIf(true, a => a.Id == c.icitem_id).FirstOrDefault();
                var childBom = bomlist.WhereIf(true, a => a.icitem_id == c.icitem_id).FirstOrDefault();
                //如果此明细查的到BOM信息，则代表此child是一个子BOM。
                if (childBom != null)
                {
                    var cdto = new BomChildExamineDto();
                    cdto.id = help.NextId();
                    cdto.level = level;
                    cdto.parent_id = dto.id;
                    cdto.bom_child_id = c.Id;
                    cdto.qty = c.qty.Value;
                    cdto.backflush = c.backflush;
                    cdto.num = childNum;
                    cdto.isbom = 1;
                    cdto.is_replace = c.is_replace;
                    cdto.haveicsubs = c.haveicsubs;
                    cdto.substitute_code = c.substitute_code;
                    cdto.icitem_ids = c.icitem_ids;
                    cdto.type = type;
                    cdto.item_id = childBom.icitem_id;
                    cdto.bom_id = childBom.Id;
                    //递归寻找子级
                    GetBomList(bomlist, bomchildlist, icitemlist, cdto, returnlist, type);
                }
                else
                {
                    if (icitem != null)
                    {
                        var childDto = new BomChildExamineDto();
                        childDto.level = level;
                        childDto.bom_id = dto.bom_id;
                        childDto.bom_child_id = c.Id;
                        childDto.id = help.NextId();
                        childDto.parent_id = dto.id;
                        childDto.item_id = icitem.Id;
                        childDto.item_name = icitem.name;
                        childDto.item_code = icitem.number;
                        childDto.num = childNum;
                        childDto.model = icitem.model;
                        childDto.unit = c.unit;
                        childDto.erp_cls = item.erp_cls;
                        childDto.erp_cls_name = item.erp_cls_name;
                        childDto.backflush = c.backflush;
                        childDto.qty = c.qty.Value;
                        childDto.isbom = 0;
                        childDto.is_replace = c.is_replace;
                        childDto.haveicsubs = c.haveicsubs;
                        childDto.substitute_code = c.substitute_code;
                        childDto.icitem_ids = c.icitem_ids;
                        childDto.type = type;
                        returnlist.Add(childDto);
                    }
                }
                idx++;
            }

        }


        /// <summary>
        /// BOM替代关系预处理
        /// </summary>
        public void BomSubstitute(List<BomChildExamineDto> returnlist, List<ic_bom> bomlist, List<ic_bom_child> bomchildlist, List<ic_item> icitemlist)
        {
            List<string> codeList = returnlist.Select(c => c.substitute_code).ToList();
            var sublist = _ic_substitute.GetManyByCondition(p => codeList.Contains(p.substitute_code) && !p.IsDeleted).Result;

            List<long> subidlist = sublist.Select(c => c.Id).ToList();
            var suballlist = _ic_substitute_all.GetManyByCondition(p => subidlist.Contains(p.substitute_id) && !p.IsDeleted).Result;

            List<long> suballidlist = suballlist.Select(c => c.Id).ToList();
            var subdtllist = _ic_substitute_all_dtl.GetManyByCondition(p => suballidlist.Contains(p.substitute_allid) && !p.IsDeleted).Result;

            List<long> childidList = new List<long>();
            int type = 1;
            List<BomChildExamineDto> addlist = new List<BomChildExamineDto>();

            //除顶级外，其他层级关系全带出来。生成平铺
            foreach (var item in returnlist)
            {
                //最顶级、虚拟件
                if (item.level != 1 && item.erp_cls != 4 && !childidList.Contains(item.bom_child_id.GetValueOrDefault()))
                {
                    //有替代关系
                    if (item.haveicsubs == 1)
                    {
                        if (!string.IsNullOrEmpty(item.icitem_ids))
                        {
                            long cid = 1;
                            var cids = item.icitem_ids.Split(',');
                            foreach (var c in cids)
                            {
                                if (long.TryParse(c, out cid))
                                {
                                    childidList.Add(cid);
                                }
                            }
                        }


                        //找到当前物料的替代群组关系集
                        var sl = sublist.Find(s => s.substitute_code == item.substitute_code);
                        if (sl != null)
                        {
                            var sall = suballlist.Where(s => s.substitute_id == sl.Id).ToList();
                            foreach (var sal in sall)
                            {
                                var sadl = subdtllist.Where(s => s.substitute_allid == sal.Id).ToList();
                                List<long> dtlItemId = sadl.Select(m => m.icitem_id).ToList();
                                var dtlitemlist = _ic_item.GetManyByCondition(p => dtlItemId.Contains(p.Id) && !p.IsDeleted).Result;
                                icitemlist.AddRange(dtlitemlist);
                                foreach (var dtl in sadl)
                                {
                                    if (dtl.ismain != 0)//替代关系里，已经将BOM料当成主料存放于替代群组里了。
                                    {
                                        //递归将替代关系组装出来。
                                        SubstitutePretreatment(sl, sal, dtl, item, addlist, icitemlist, bomlist, bomchildlist, type);
                                    }
                                    else
                                    {
                                        //将主料赋值上属性
                                        var dtlitem = returnlist.Find(s => s.item_id == dtl.icitem_id && s.level == item.level);
                                        dtlitem.substitute_all_num = sal.order_num;//群组优先级
                                    }
                                }
                            }
                        }
                    }
                }
            }
            returnlist.AddRange(addlist);
        }

        /// <summary>
        /// 替代关系递归组装出来
        /// </summary>
        /// <param name="sal"></param>
        /// <param name="dtl"></param>
        /// <param name="toDto"></param>
        /// <param name="returnlist"></param>
        /// <param name="icitemlist"></param>
        /// <param name="bomlist"></param>
        /// <param name="bomchildlist"></param>
        public void SubstitutePretreatment(ic_substitute sl, ic_substitute_all sal, ic_substitute_all_dtl dtl, BomChildExamineDto toDto, List<BomChildExamineDto> returnlist, List<ic_item> icitemlist, List<ic_bom> bomlist, List<ic_bom_child> bomchildlist, int type)
        {
            //如果dtl对应的icitem是BOM，还需要向下继续展开。

            //List<BomChildExamineDto> returnlist = new List<BomChildExamineDto>();
            var dto = new BomChildExamineDto();
            var bom = bomlist.WhereIf(true, s => s.icitem_id == dtl.icitem_id).FirstOrDefault();
            var icitem = icitemlist.Find(s => s.Id == dtl.icitem_id);
            if (icitem == null)
            {
                return;
            }
            dto.id = help.NextId();
            dto.level = toDto.level;
            dto.parent_id = toDto.parent_id;
            dto.item_id = icitem.Id;
            dto.item_name = icitem.name;
            dto.item_code = icitem.number;
            dto.num = toDto.num;
            dto.model = icitem.model;
            dto.unit = icitem.unit;
            dto.erp_cls = icitem.erp_cls;
            dto.erp_cls_name = icitem.erp_cls_name;
            dto.backflush = toDto.backflush;
            //dto.qty = toDto.qty;
            //dto.replace_amount = dtl.replace_amount.Value;
            dto.qty = dtl.replace_amount == null ? 1 : dtl.replace_amount.Value;
            dto.is_replace = 0;
            dto.haveicsubs = 0;
            dto.substitute_code = "";
            dto.icitem_ids = "";
            dto.substitute_strategy = sl.substitute_strategy == null ? 0 : sl.substitute_strategy.Value;//替代策略
            dto.substitute_mode = sl.substitute_mode == null ? 0 : sl.substitute_mode.Value;//替代方式
            dto.type = type;
            dto.substitute_all_num = sal.order_num;//群组优先级
            if (bom != null)
            {
                dto.bom_id = bom.Id;

                dto.qty = dtl.replace_amount == null ? 1 : dtl.replace_amount.Value;
                dto.isbom = 1;
                dto.is_replace = 0;
                dto.haveicsubs = 0;
                dto.substitute_code = "";
                dto.icitem_ids = "";
                GetBomList(bomlist, bomchildlist, icitemlist, dto, returnlist, type);
            }
            else
            {
                dto.bom_id = null;
                dto.isbom = 0;
                returnlist.Add(dto);
            }
        }

        /// <summary>
        /// 计算物料库存量
        /// </summary>
        /// <param name="returnlist"></param>
        public void BomStock(List<BomChildExamineDto> returnlist, long bangid, long factoryid)
        {
            returnlist = returnlist.OrderBy(s => s.num).ToList();
            //获取当前工厂下物料库存数据
            List<long> icitemIds = returnlist.Select(c => c.item_id).ToList();
            var stocklist = _ic_item_stock.GetManyByCondition(p => p.factory_id == factoryid && icitemIds.Contains(p.icitem_id)).Result;
            //取当前订单的物料库存占用记录
            //var occupylist = _ic_item_stockoccupy.GetManyByCondition(p => p.bang_id == bangid && p.order_id == orderid).Result;
            //计算剩余库存
            foreach (var item in returnlist)
            {
                if (item.erp_cls == 4)//虚拟件不计算
                {
                    continue;
                }
                //非虚拟件
                //当前物料的库存数量
                decimal stockQty = stocklist.Where(s => s.icitem_id == item.item_id).Sum(p => p.sqty.GetValueOrDefault());
                //获取当前订单其他订单行当前物料的占用数量
                //decimal otherStockQty = occupylist.Where(s => s.icitem_id == item.item_id).Sum(p => p.quantity);
                //当前订单行物料库存情况
                //item.sqty = stockQty - otherStockQty;
                item.sqty = stockQty;
            }
        }

        /// <summary>
        /// 替代关系计算
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="bangid"></param>
        /// <param name="orderid"></param>
        /// <param name="count"></param>
        /// <param name="input"></param>
        /// <param name="plan_date"></param>
        public void calcTest(List<BomChildExamineDto> returnlist, long bangid, long orderid, decimal count, SeorderentryDto input, DateTime
            ? plan_date)
        {
            //占用情况
            List<ic_item_stockoccupy> sklist = new List<ic_item_stockoccupy>();
            //var occupylist = _ic_item_stockoccupy.GetManyByCondition(p => p.icitem_id == bangid && p.order_id == orderid).Result;

            //第一级
            returnlist = returnlist.OrderBy(s => s.num).ToList();
            var childList = returnlist.Where(s => s.parent_id == returnlist[0].id && s.type == 0).ToList();

            //1.如果主料够的时候，不需要显示替代料的平铺视图，如果主料不够，显示替代料的平铺视图。
            //2.替代策略和替代方式，影响到的是甲乙组概念，替代按主料有限，取代按组的优先级。A与B的替代，则A和B各自会存在一个组。
            List<long> calcIds = new List<long>();
            //先处理下最顶级的产品需要数量
            returnlist[0].needCount = returnlist[0].qty * count;
            returnlist[0].lack_qty = returnlist[0].needCount - returnlist[0].sqty;
            if (returnlist[0].lack_qty > 0)
            {
                var seorderentry = _mysql_crm_seorderentry.FindAsync(x => x.Id == orderid).Result;
                //生成自制工单
                GenerateMorder(seorderentry, returnlist[0].lack_qty);
            }
            foreach (var item in returnlist)
            {
                if (item.level == 1)
                {
                    continue;
                }
                //循环平铺整个资源检查的物料库存情况、缺料情况，子集缺料需要用父级缺料*子集使用数量-
                CaclMaterialShortage(returnlist, item, count);
            }

            //这是从上往下展开计算缺料和可制
            calcTest2(returnlist[0], childList, returnlist, sklist);
            //returnlist[0].kz = childList.Min(s => s.kz);//得到最小可制数量。
            //再加个循环，来根据替代关系里的检查结果，根据规则明确使用和生成占用关系。


            foreach (var item in childList)
            {
                if (item.haveicsubs == 1)
                {
                    //如果有替代关系，根据群组来明确使用哪个群组的替代料。按整批和混用逻辑来算
                    // 如果有群组替代，就移除掉被检查过的记录 item.icitem_ids
                    CalcStrategy(item, returnlist, bangid, sklist, input, plan_date);
                }
                else
                {
                    //直接占用库存，缺料就生成采购
                    ic_item_stockoccupy itemStockoccupyDto = new ic_item_stockoccupy();
                    itemStockoccupyDto.bang_id = bangid;
                    itemStockoccupyDto.icitem_id = item.item_id;
                    itemStockoccupyDto.quantity = item.sqty;
                    sklist.Add(itemStockoccupyDto);
                    item.is_use = true;
                    if (item.erp_cls == 1)
                    {
                        //走自制
                    }
                    else if (item.erp_cls == 2 || item.erp_cls == 3)
                    {
                        var leadTimeList = GetLeadTime(new List<long> { item.item_id }, input.tenantId, input.factoryId);//提前期列表
                        var supplierList = GetSupplier(new List<BomChildExamineDto> { item }, input.tenantId, input.factoryId);//供应商列表
                        var planList = GetICPlan(new List<BomChildExamineDto> { item }, input.tenantId, input.factoryId);//plan列表
                        item.kitting_time = CreateSRMPR(item, input.tenantId, input.factoryId, bangid, item.erp_cls, leadTimeList, supplierList, planList, plan_date.Value);
                        if (item.erp_cls == 3)
                        {
                            //生成委外工单
                            CreateMesOOder(item, input.tenantId, input.factoryId, bangid, leadTimeList, supplierList, plan_date.Value);
                        }
                    }
                }
            }
        }


        /// <summary>
        /// 平铺计算物料情况
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="item"></param>
        /// <param name="count"></param>
        public void CaclMaterialShortage(List<BomChildExamineDto> returnlist, BomChildExamineDto item, decimal count)
        {
            var parent = returnlist.Find(s => s.id == item.parent_id);
            //当前物料总共需要数量
            item.needCount = parent.needCount * item.qty;
            /*//当前库存可以满足的数量
            item.satisfyNum = item.sqty;
            //总需要数量减去库存量，得出缺料数量
            item.lack_qty = item.needCount - item.satisfyNum;
            //如果不满足，计算子物料，或者计算替代料
            if (item.lack_qty < 0)
            {
                //库存满足
                item.stock_state = 1;
                item.lack_qty = 0;
            }
            else
            {
                item.stock_state = 0;
            }*/
        }

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

        /// <summary>
        /// 根据替代策略计算
        /// </summary>
        /// <param name="item"></param>
        /// <param name="returnlist"></param>
        /// <param name="bangid"></param>
        /// <param name="sklist"></param>
        /// <param name="input"></param>
        /// <param name="plan_date"></param>
        public void CalcStrategy(BomChildExamineDto item, List<BomChildExamineDto> returnlist, long bangid, List<ic_item_stockoccupy> sklist, SeorderentryDto input, DateTime
            ? plan_date)
        {
            //提取群组关系
            var sublist = returnlist.Where(s => s.parent_id == item.parent_id && s.num == item.num && s.level == item.level).OrderBy(c => c.substitute_all_num).ToList();
            List<BomChildExamineDto> select = new List<BomChildExamineDto>();
            var parent = returnlist.Find(s => s.id == item.parent_id);
            switch (item.substitute_strategy)
            {
                case 0://整批
                    WholeBatchCheck(sublist, returnlist, sklist, select);
                    //如果都需要采购的情况下，则默认使用优先级最高的
                    WholeBatch(item, sublist, returnlist, sklist, select, bangid, parent, input, plan_date);
                    break;
                case 1://混用
                    MixedUse(item, sublist, returnlist, sklist, bangid, parent, input, plan_date);
                    break;
                case 2://整批加混用
                    WholeBatchCheck(sublist, returnlist, sklist, select);
                    if (select.Count() == 0)
                    {
                        //走混用
                        MixedUse(item, sublist, returnlist, sklist, bangid, parent, input, plan_date);
                    }
                    else
                    {
                        //走整批
                        WholeBatch(item, sublist, returnlist, sklist, select, bangid, parent, input, plan_date);
                    }
                    break;
            }
        }
        /// <summary>
        /// 整批计算
        /// </summary>
        /// <param name="sublist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="select"></param>
        public void WholeBatchCheck(List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<ic_item_stockoccupy> sklist, List<BomChildExamineDto> select)
        {
            for (int idx = 0; idx < 99; idx++)
            {
                var list = sublist.Where(s => s.substitute_all_num == idx).ToList();
                if (list.Any())
                {
                    foreach (var s in list)
                    {
                        RecalculationStock(s, returnlist, sklist);
                    }
                    if (list.Where(s => s.stock_state != 1).Count() == 0)
                    {
                        //只满足充足或可制
                        //无缺料情况
                        select = list;
                        select.ForEach(s => { s.is_use = true; });
                        break;
                    }
                    idx++;
                }
                else
                {
                    idx = 99;
                }
            }
        }
        /// <summary>
        /// 整批占用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sublist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="select"></param>
        /// <param name="bangid"></param>
        /// <param name="parent"></param>
        /// <param name="input"></param>
        /// <param name="plan_date"></param>
        public void WholeBatch(BomChildExamineDto item, List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<ic_item_stockoccupy> sklist, List<BomChildExamineDto> select, long bangid, BomChildExamineDto parent, SeorderentryDto input, DateTime
            ? plan_date)
        {
            if (select.Count() == 0)
            {
                //如果为空，则默认使用优先级为0的集合作为替代关系
                if (item.substitute_mode == 0)
                {
                    //替代
                    select = sublist.Where(s => s.type == 0).ToList();
                }
                else
                {
                    //取代
                    select = sublist.Where(s => s.substitute_all_num == 0).ToList();
                }
                select.ForEach(s => { s.is_use = true; });
            }
            //占用库存
            foreach (var slt in select)
            {
                ic_item_stockoccupy itemStockoccupyDto = new ic_item_stockoccupy();
                itemStockoccupyDto.bang_id = bangid;
                itemStockoccupyDto.icitem_id = slt.item_id;
                slt.is_use = true;
                if (slt.lack_qty > 0)
                {

                    itemStockoccupyDto.quantity = slt.sqty;
                    //库存不够的时候，根据属性生成采购和委外。
                    if (slt.erp_cls == 1)
                    {
                        slt.make_qty = slt.lack_qty;
                        /*var childList = returnlist.Where(s => s.parent_id == slt.id).ToList();
                        if (childList.Count() > 0)
                        {
                            CalcStrategy(slt, returnlist, bangid, sklist);
                        }*/
                    }
                    else if (slt.erp_cls == 2 || slt.erp_cls == 3)
                    {   //生成采购订单
                        //slt.purchase_qty = slt.lack_qty;
                        var leadTimeList = GetLeadTime(new List<long> { slt.item_id }, input.tenantId, input.factoryId);//提前期列表
                        var supplierList = GetSupplier(new List<BomChildExamineDto> { slt }, input.tenantId, input.factoryId);//供应商列表
                        var planList = GetICPlan(new List<BomChildExamineDto> { slt }, input.tenantId, input.factoryId);//plan列表

                        slt.kitting_time = CreateSRMPR(slt, input.tenantId, input.factoryId, bangid, slt.erp_cls, leadTimeList, supplierList, planList, plan_date.Value);
                        if (item.erp_cls == 3)
                        {
                            //生成委外工单
                            CreateMesOOder(item, input.tenantId, input.factoryId, bangid, leadTimeList, supplierList, plan_date.Value);
                        }
                    }
                }
                else
                {
                    itemStockoccupyDto.quantity = slt.needCount;
                    if (parent != null)
                    {   //如果不缺料的情况下，则占用掉父级缺料乘以当前子集使用料数量
                        itemStockoccupyDto.quantity = parent.lack_qty * slt.qty - slt.sqty;
                    }
                }
                sklist.Add(itemStockoccupyDto);
            }

        }

        /// <summary>
        /// 混用占用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sublist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sklist"></param>
        /// <param name="bangid"></param>
        /// <param name="parent"></param>
        /// <param name="input"></param>
        /// <param name="plan_date"></param>
        public void MixedUse(BomChildExamineDto item, List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<ic_item_stockoccupy> sklist, long bangid, BomChildExamineDto parent, SeorderentryDto input, DateTime
            ? plan_date)
        {

            decimal parent_lack = 0;
            if (parent != null)
            {
                parent_lack = parent.lack_qty;
            }
            for (int idx = 0; idx < 99; idx++)
            {
                if (parent_lack <= 0)
                {
                    break;
                }

                var list = sublist.Where(s => s.substitute_all_num == idx).ToList();
                if (list.Any())
                {
                    foreach (var s in list)
                    {
                        RecalculationStock(s, returnlist, sklist);
                    }
                    decimal minMake = 9999999;
                    foreach (var hy in list)
                    {
                        //混用先使用掉当前要用的数量
                        //得到库存最小数量，去占用，然后剩余的丢第二个循环里去占用。
                        decimal make = hy.sqty / hy.qty;
                        if (minMake > make)
                        {
                            minMake = make;
                        }
                    }
                    decimal use_p_num = 0;
                    if (parent_lack > minMake) //20>10
                    {
                        use_p_num = minMake;
                        parent_lack -= use_p_num;
                    }
                    else
                    {
                        use_p_num = parent_lack;
                        parent_lack = 0;
                    }
                    //根据混用逻辑，去占用物料
                    foreach (var zy in list)
                    {
                        zy.is_use = true;
                        ic_item_stockoccupy itemStockoccupyDto = new ic_item_stockoccupy();
                        itemStockoccupyDto.bang_id = bangid;
                        itemStockoccupyDto.icitem_id = zy.item_id;
                        itemStockoccupyDto.quantity = use_p_num * zy.qty; ;
                        sklist.Add(itemStockoccupyDto);
                    }
                    idx++;
                }
            }
            if (parent_lack > 0)
            {
                var select = new List<BomChildExamineDto>();
                if (item.substitute_mode == 0)
                {
                    //替代
                    select = sublist.Where(s => s.type == 0).ToList();
                }
                else
                {
                    //取代
                    select = sublist.Where(s => s.substitute_all_num == 0).ToList();
                }
                //对select执行采购
                foreach (var sct in select)
                {
                    //找到当前物料的占用记录
                    var itemSockoccupy = sklist.Where(s => s.icitem_id == sct.item_id).ToList();
                    var num = parent_lack * sct.qty - itemSockoccupy.Sum(m => m.quantity);
                    if (sct.erp_cls == 1)
                    {
                        //自制
                        //GenerateMorder()
                    }
                    else if (sct.erp_cls == 2 || sct.erp_cls == 3)
                    {
                        var leadTimeList = GetLeadTime(new List<long> { sct.item_id }, input.tenantId, input.factoryId);//提前期列表
                        var supplierList = GetSupplier(new List<BomChildExamineDto> { sct }, input.tenantId, input.factoryId);//供应商列表
                        var planList = GetICPlan(new List<BomChildExamineDto> { sct }, input.tenantId, input.factoryId);//plan列表
                        sct.kitting_time = CreateSRMPR(sct, input.tenantId, input.factoryId, bangid, sct.erp_cls, leadTimeList, supplierList, planList, plan_date.Value);
                        if (item.erp_cls == 3)
                        {
                            //生成委外工单
                            CreateMesOOder(item, input.tenantId, input.factoryId, bangid, leadTimeList, supplierList, plan_date.Value);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 可制占用计算---暂时未用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="returnlist"></param>
        /// <param name="bangid"></param>
        /// <param name="kznun"></param>
        public void Sockoccupy(BomChildExamineDto item, List<BomChildExamineDto> returnlist, long bangid, decimal kznun)
        {
            ic_item_stockoccupy itemStockoccupyDto = new ic_item_stockoccupy();
            itemStockoccupyDto.bang_id = bangid;
            if (item.stock_state == 1)
            {
                //成品库存占用
                //slt.needCount
                //可制物料占用
                //slt.kz;如果是BOM，就展开BOM占用子物料
                itemStockoccupyDto.icitem_id = item.item_id;
                itemStockoccupyDto.quantity = item.needCount;
            }
            else if (item.stock_state == 2 || item.stock_state == 3)
            {
                itemStockoccupyDto.quantity = item.sqty;
                var num = item.lack_qty;//可制满足的情况下，直接占用可制。
                var sltChild = returnlist.Where(s => s.parent_id == item.id).ToList();
                if (sltChild.Count() > 0)
                {
                    //有子集，则代表每条明细的库存加可制，才是父级的可制。
                    foreach (var c in sltChild)
                    {
                        Sockoccupy(c, returnlist, bangid, num);
                    }
                }
            }
            //如果存在外购或者委外
            else if (item.stock_state == 4 || item.stock_state == 5)
            {
                //根据最小颗粒度
            }
        }

        /// <summary>
        /// 计算物料是否缺料
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="bzlist"></param>
        /// <param name="returnlist"></param>
        /// <param name="sockoccupyList"></param>
        public void calcTest2(BomChildExamineDto parent, List<BomChildExamineDto> bzlist, List<BomChildExamineDto> returnlist, List<ic_item_stockoccupy> sockoccupyList)
        {
            //从第二级开始循环
            foreach (var item in bzlist)
            {
                var childList = returnlist.Where(s => s.parent_id == item.id).ToList();

                //存在替代关系
                if (item.haveicsubs == 1)
                {
                    //提取群组关系
                    var sublist = returnlist.Where(s => s.parent_id == item.parent_id && s.num == item.num && s.level == item.level).OrderBy(c => c.substitute_all_num).ToList();
                    //循环计算群组，看哪个群组满足要求，然后使用此群组，将群组的库存和子物料占用掉。
                    //计算此次群组是否有符合
                    MaterialCalc(sublist, returnlist, sockoccupyList);
                }
                else
                {
                    //根据占用情况计算库存
                    Calczykc(item, sockoccupyList);
                    //如果有子集，则丢入循环，判断下库存可制等信息。
                    calcTest2(item, childList, returnlist, sockoccupyList);
                    /*item.kz = childList.Min(s => s.kz);
                    if (item.kz >= item.lack_qty)
                    {
                        item.stock_state = 3;
                    }
                    else
                    {
                        item.stock_state = 0;
                    }*/
                }
            }
        }

        /// <summary>
        /// 递归计算物料信息
        /// </summary>
        /// <param name="sublist"></param>
        public void MaterialCalc(List<BomChildExamineDto> sublist, List<BomChildExamineDto> returnlist, List<ic_item_stockoccupy> sockoccupyList)
        {
            int maxIdx = sublist.Max(s => s.substitute_all_num);
            for (int i = 0; i <= maxIdx; i++)
            {
                var group = sublist.Where(s => s.substitute_all_num == i).ToList();
                // int boolCount = 0;//代表某一颗物料无需采购，可以自制，则集合+1。

                //如果替代料库存不够，但是可制够，则也考虑使用优先级最高
                foreach (var g in group)
                {
                    //根据占用情况计算库存
                    Calczykc(g, sockoccupyList);
                    /*if (g.stock_state != 1)
                    {
                        //判断此料是否BOM，如果是BOM，就考虑自制是否足够，此处递归检查子集
                        var gChildList = returnlist.Where(s => s.parent_id == g.id).ToList();
                        if (gChildList.Count > 0)
                        {
                            calcTest2(g, gChildList, returnlist, sockoccupyList);
                            //如果是自制，则考虑自制够不够
                            if (g.erp_cls == 1)
                            {
                                foreach (var cc in gChildList)
                                {
                                    //如果子物料是BOM，则当前物料的可制数量应该是子物料的库存加子物料的可制除以子物料的使用量
                                    if (returnlist.Where(s => s.parent_id == cc.id).Count() > 0)
                                    {
                                        cc.kz = Math.Floor((cc.sqty + cc.kz) / g.qty);
                                    }
                                }
                                g.kz = gChildList.Min(s => s.kz);//得到最小可制数量。
                                
                                //todo:如果是群组替代，可制数量应该跟随着主料来，不应该受限于最小可制单元。
                                g.stock_state = gChildList.Max(s => s.stock_state);
                                if (g.lack_qty <= g.kz)
                                {
                                    g.stock_state = 2;
                                    boolCount++;
                                }
                            }
                        }
                        else
                        {
                            g.kz = Math.Floor(g.sqty / g.qty);//自己不是BOM的情况下，算一下自己可制父级可以制造多少个，这个可制只是基于父级BOM才用来运算。
                            //todo:申老师说，如果是苏州工厂，原材料有可能也是自制的。
                            //所以这里在计算时，还可以直接拿缺料数量，去丢给苏州计算方法，得出原材料的库存加可制。
                        }
                    }
                    else
                    {
                        boolCount++;
                    }*/
                }

                /*if (boolCount == group.Count())
                {
                    //如果检查集合满足条数与群组里的物料条数相同，则代表这个群组的数量是满足的。
                    group.ForEach(s =>
                    {
                        s.is_show = true;
                    });
                    break;//如果已经找到合适的替代群组关系，并且都不需要采购，则直接不继续检查了。
                }*/
            }
        }

        /// <summary>
        /// 根据每个物料来实时计算占用情况
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sockoccupyList"></param>
        public void Calczykc(BomChildExamineDto item, List<ic_item_stockoccupy> sockoccupyList)
        {
            //找到当前物料的占用记录
            var itemSockoccupy = sockoccupyList.Where(s => s.icitem_id == item.item_id).ToList();
            //计算库存减去占用
            item.sqty -= itemSockoccupy.Sum(s => s.quantity);
            //如果库存
            item.sqty = item.sqty < 0 ? 0 : item.sqty;
            //判断缺料数量
            item.lack_qty = item.needCount - item.sqty;
            //判断状态
            item.stock_state = item.lack_qty > 0 ? 0 : 1;
        }

        #region 替代检查第一版，屏蔽
        /*/// <summary>
        /// 替代关系检查计算
        /// </summary>
        public void CalcIcitemSubstitute(List<BomChildExamineDto> returnlist, int count)
        {
            returnlist = returnlist.OrderBy(s => s.num).ToList();
            //1.如果主料够的时候，不需要显示替代料的平铺视图，如果主料不够，显示替代料的平铺视图。
            //2.替代策略和替代方式，影响到的是甲乙组概念，替代按主料有限，取代按组的优先级。A与B的替代，则A和B各自会存在一个组。
            List<long> calcIds = new List<long>();
            //先处理下最顶级的产品需要数量
            returnlist[0].needCount = returnlist[0].qty * count;
            returnlist[0].satisfyNum = returnlist[0].sqty;
            returnlist[0].lack_qty = returnlist[0].needCount - returnlist[0].satisfyNum;
            returnlist[0].is_show = true;
            foreach (var item in returnlist)
            {
                //循环平铺整个资源检查的物料库存情况、缺料情况
                CaclMaterialShortage(returnlist, item, count);
            }
            foreach (var item in returnlist)
            {
                //替代件不计算,替代件通过标准件的替代关系，去计算需要使用哪些物料
                if (item.type == 1)
                {
                    continue;
                }
                CaclBomChildUseShortage(returnlist, item);
            }
        }

        /// <summary>
        /// 物料计算
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="item"></param>
        /// <param name="count"></param>
        public void CaclBomChildUseShortage(List<BomChildExamineDto> returnlist, BomChildExamineDto item)
        {
            //判断是否是BOM，如果是BOM，还需要向下展开
            var bomchild = returnlist.Where(s => s.parent_id == item.id).ToList();
            if (bomchild.Count > 0)
            {
                foreach (var child in bomchild)
                {
                    CaclBomChildUseShortage(returnlist, item);
                    //取子级的最高状态
                    item.stock_state = bomchild.Max(s => s.stock_state);
                    item.kitting_time = bomchild.Max(s => s.kitting_time);
                }
            }
            //var tolist = returnlist.Where(s => s.parent_id == item.parent_id && s.num == item.num).ToList();
            //有替代关系
            if (item.haveicsubs == 1)
            {
                //首先判断标准件库存是否满足。
                //如果是BOM，也需要向下展开，看子物料是否满足。
                //不满足的情况下，则需要展开替代关系，根据替代策略和替代方式，来判定替代件的库存。
                //假设子BOM有替代关系，则子BOM的子物料，也是有替代关系存在的，需要展开来看。
                //1.假设标准件库存满足，则不计算替代件关系。
                //2.如果标准件不满足，则替代件开始计算并展示。
                //注意：不管是否需要替代件，标准件都需要展开。没有使用到的物料，定义为无需求。如果子BOM库存足够，则不需要显示子物料和替代关系。
                var sublist = returnlist.Where(s => s.parent_id == item.parent_id && s.num == item.num && s.level == item.level).OrderBy(c => c.substitute_all_num).ToList();
                //sublist找出当前含替代关系的标准件和替代件。
                switch (item.substitute_strategy)
                {
                    case 0://整批
                        break;
                    case 1://混用
                        break;
                    case 2://整批加混用
                        break;
                }

                
                

                if (item.substitute_mode == 0)
                {
                    //替代
                }
                else
                {
                    //取代
                }
            }
            else//无替代关系
            {
                if (item.stock_state==0)
                {
                    item.use_qty = item.needCount;
                    item.is_show = true;
                }
                else if (item.stock_state == 1)
                {
                    item.use_qty = item.sqty;
                    // 缺料数量 item.lack_qty
                    // 使用数量将库存全部使用了 item.use_qty = item.sqty;
                    if (item.erp_cls == 2 || item.erp_cls == 3)
                    {
                        //委外、外购
                        //生成委外工单、采购申请单
                        //得到单据到货时间。
                        //todo:初步设置为7天到货期，后期根据实际业务来补充修改。
                        item.kitting_time = DateTime.Now.AddDays(7);
                        item.stock_state = 2;
                    }
                    else if (item.erp_cls == 1)
                    {
                        //自制
                        //调用产能计算，得到物料自制后的齐套时间。
                        //todo:初步设置为7天完成，等沟通调用方法，来修改此处。
                        item.kitting_time = DateTime.Now.AddDays(7);
                        item.stock_state = 3;
                    }
                }
            }
        }

        /// <summary>
        /// 平铺物料缺料情况，展示所有主料+替代料的库存情况、缺料情况---需要修改成  库存情况、占用情况
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="item"></param>
        /// <param name="count"></param>
        public void CaclMaterialShortage(List<BomChildExamineDto> returnlist, BomChildExamineDto item, int count)
        {
            var parent = returnlist.Find(s => s.id == item.parent_id);
            //当前物料总共需要数量
            item.needCount = parent.needCount * item.qty;
            //当前库存可以满足的数量
            item.satisfyNum = item.sqty;
            //总需要数量减去库存量，得出缺料数量
            item.lack_qty = item.needCount - item.satisfyNum;
            //如果不满足，计算子物料，或者计算替代料
            if (item.lack_qty < 0)
            {
                //库存满足
                item.stock_state = 0;
                item.lack_qty = 0;
            }
            else
            {
                //找出自己的子集，存在子集则是BOM，不存在子集，则自己非BOM。
                var childList = returnlist.Where(s => s.parent_id == item.id && s.type == item.type).ToList();
                if (childList.Count > 0)
                {
                    //自己是BOM
                    decimal kz = 0;//当前BOM可制数量
                    foreach (var child in childList)
                    {
                        //循环子集判断库存
                        CaclMaterialShortage(returnlist, child, count);
                        kz = kz > ((child.sqty+ child.kz) / child.qty) ? Math.Floor((child.sqty + child.kz) / child.qty) : kz;
                    }
                    //向下取整
                    item.kz =Math.Floor(kz);
                }
                else
                {
                    //原材料没有可制数量。
                    item.kz = 0;
                    item.stock_state = 1;
                }
            }
        }*/
        #endregion

        /// <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<ic_factory_details> project = new ProjectionDefinitionBuilder<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)).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 }).AsQueryable<ICItemLeadTimeDto>().ToList();
        }

        //根据物料id获取物料供应商
        private List<ic_item_pur> GetSupplier(List<BomChildExamineDto> returnlist, long tenantId, long factoryid)
        {
            return _ic_item_pur.Find(p => returnlist.Select(x => x.item_id).Contains(p.icitem_id) && p.tenant_id == tenantId && p.factory_id == factoryid && !p.IsDeleted).Result;
        }

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


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

        /// <summary>
        /// 生成委外工单
        /// </summary>
        /// <param name="returnlist"></param>
        /// <param name="factoryid"></param>
        private DateTime CreateMesOOder(BomChildExamineDto returnlist, long tenantId, long factoryid, long bangId, List<ICItemLeadTimeDto> iCItemLeadTimes, List<ic_item_pur> supplierList, DateTime deliveryDate)
        {
            mes_oorder oOrder = new mes_oorder();
            oOrder.GenerateNewId();
            oOrder.oorder_no = getOrderNum("WW");//生产工单编号
            oOrder.oorder_type = "委外工单";//生产工单类型
            oOrder.oorder_date = DateTime.Now;//委外订单日期
            oOrder.oorder_state = "已提交";//订单状态
            oOrder.ooentry_prd = 10000;//生产组织
            oOrder.ooentry_prdname = "1000";//生产组织名称
            oOrder.ooentry_wrkc = 10000;//工作中心id
            oOrder.ooentry_wrkcname = "10001";//工作中心名称
            oOrder.planner_num = "wwww";//计划员工号
            oOrder.planner_name = "qqq";//计划员名称
            oOrder.ooentry_stime = DateTime.Now;//计划开工日期
            oOrder.ooentry_etime = DateTime.Now;//计划完工日期
            oOrder.product_code = "产品代码";//产品代码
            oOrder.ffms_number = "1000";//fms旧料号
            oOrder.product_name = "test";//产品名称
            oOrder.specification_model = returnlist.model;//规格型号
            oOrder.bom_number = "";//bom编码
            oOrder.unit = returnlist.unit;//单位
            oOrder.morder_progress = "";//工单进度
            oOrder.morder_production_number = returnlist.lack_qty;//工单生产数量(计划数量)
            oOrder.need_number = returnlist.lack_qty;//需求数量
            oOrder.remaining_number = returnlist.lack_qty;//剩余可用数量
            oOrder.work_number = 0;//报工数量
            oOrder.inspection_number = 0;//报检数量
            oOrder.qualified_number = 0;//合格数量
            oOrder.inventory_number = 0;//入库数量
            oOrder.notice_qty = 0;//已开通知单数量
            oOrder.moentry_on = 1;//启动状态
            //oOrder.start_time = DateTime.Now;//开始时间
            //oOrder.pause_time = DateTime.Now;//最近暂停时间
            //oOrder.restart_time = DateTime.Now;//最近重启时间
            oOrder.project_name = returnlist.item_name;//项目名称
            oOrder.sent_status = 1;//发料状态 1-待发料  2-已发料
            oOrder.production_unit = returnlist.unit;//加工单位
            oOrder.production_unit_code = "";//加工单位编码
            oOrder.need_icitem_status = 1;//所需物料是否充足  1-充足 0-缺料
            oOrder.tenant_id = tenantId;
            oOrder.factory_id = factoryid;
            oOrder.bang_id = bangId;
            _mes_oorder.InsertOne(oOrder);
            return DateTime.Now;
        }


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

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