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 XCZ.Extensions;
using System.ComponentModel.Design;
using Volo.Abp.Validation.StringValues;
using System.Runtime.CompilerServices;
using MongoDB.Driver;
using Volo.Abp.Validation.Localization;
using Hangfire.Annotations;

namespace Business.ResourceExamineManagement
{
    /// <summary>
    /// 资源检查
    /// </summary>
    //[Authorize(BusinessPermissions.ResourceExamine.Default)]
    public class ResourceExamineAppService : ApplicationService, IResourceExamineAppService
    {
        #region 服务
        /// <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;

        /// <summary>
        /// 工艺关联工序
        /// </summary>
        private readonly IMongoDB<mes_tech_process> _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_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_mooccupy> _mes_mooccupy;
        /// <summary>
        /// 销售工单
        /// </summary>
        private readonly IRepository<crm_seorder> _crm_seorder;
        /// <summary>
        /// 销售工单
        /// </summary>
        private readonly IRepository<crm_seorderentry> _crm_seorderentry;
        #endregion

        /// <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_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_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
            )
        {
            _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_substitute = ic_substitute;
            //_ic_substitute_all = ic_substitute_all;
            //_ic_substitute_all_dtl = ic_substitute_all_dtl;
            _mes_morder = mes_morder;
            _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;
            _crm_seorder = mysql_crm_seorder;
            _crm_seorderentry = mysql_crm_seorderentry;
            _mysql_mes_technique = mysql_mes_technique;
            _mysql_ic_item_stock = mysql_ic_item_stock;
        }

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

        /// <summary>
        /// 资源检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<PschedDto> ReceiveResult(SeorderentryDto input)
        {
            //数据库快照-同步mysql库数据到mongoDB中
            await SyncData();
            //生成当前计算bangid
            //SnowFlake snow = new SnowFlake();
            //long bangid = snow.NextId();

            ////产能检查
            //await ProductiveExamine(1733221167209762816, 100);
            return null;
            throw new NotImplementedException();
        }

        /// <summary>
        /// 数据库快照
        /// </summary>
        /// <returns></returns>
        public async Task SyncData()
        {
            //同步物料库存数据
            var icitemStokc = _mysql_ic_item_stock.GetQueryableAsync().Result.ToListAsync().Result;
            if (icitemStokc.Count > 0)
            {
                await _ic_item_stock.InsertMany(icitemStokc);
            }
        }

        /// <summary>
        /// 产能计算
        /// </summary>
        /// <param name="tech_id">工艺路径主键</param>
        /// <param name="packages">需要生产产品件数</param>
        public async Task<DateTime> ProductiveExamine(long tech_id, int packages)
        {
            if (packages <= 0)
            {
                throw new NotImplementedException("产能计算参数有误！");
            }
            #region 1、数据准备
            //1.1、获取工艺路径数据
            mes_technique tech = await _mes_technique.GetOneByID(tech_id);

            //1.2、获取工艺路径关联工序数据
            List<mes_tech_process> tech_Processes = await _mes_tech_process.GetManyByCondition(x => x.tech_id == tech_id);

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

            //1.3、获取工艺工序关联工位信息
            FilterDefinition<mes_tech_proc_workshop> filter1 = Builders<mes_tech_proc_workshop>.Filter.In(s => s.tech_proc_id, tech_Processes.Select(m => m.Id).ToList());
            List<mes_tech_proc_workshop> tech_Proc_Workshops = await _mes_tech_proc_workshop.GetManyByIds(filter1);
            #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).OrderBy(m => m.Id).ToList();
            if (fistChilds.Count == 0)
            {
                throw new NotImplementedException("当前工艺路径没有配置工序，请调整！");
            }
            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;
                dto.nextproc_id = chd.nextprocid;
                dto.wait_time = curTakeTime;
                starts.Add(dto);
            }
            #endregion

            return DateTime.Now.AddDays(1).AddMinutes((double)sumTimes);
        }

        /// <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(生产一件所需时间)
            {
                takeTime = quantity * proc.ct.Value;
                return takeTime;
            }
            else if (proc.wctype == 3)//设备型:向上取整(数量/一次可加工数量)*ct(老化一次所需时间)
            {
                takeTime = Math.Ceiling(quantity / proc.upe.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 async Task GenerateMorder(long seorderentry_id)
        {
            //需要生成的物料，需要生产的数量，对应销售订单。

            //1.库存、在制工单检查完成后 当前BOM需要自制时 产生工单。

            //2.每一个销售订单行对应一个工单。
            //获取销售订单信息
            //var seorder = await _crm_seorder.FindAsync(x => x.Id == OrderId);
            //查询销售订单子表数据
            var seorderentry = await _crm_seorderentry.FindAsync(x => x.Id == seorderentry_id);

            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 = "初始";


        }
        /// <summary>
        /// 检查成品库存
        /// </summary>
        /// <param name="seorderentry_id">销售订单子表ID</param>
        /// <returns></returns>
        public async Task<bool> CheckFinishedProductInventory(long seorderentry_id)
        {
            //获取销售订单子表
            var seorderentry = await _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).Result.FirstOrDefault();
            //物料库存表
            var ic_Item_Stocks = await _ic_item_stock.GetManyByCondition(x => x.icitem_id == ic_bom.icitem_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<List<mes_morder>> CheckMorder(string bomNumber, decimal? Quantity, DateTime DeliverDate, long seorderentry_id)
        {
            if (string.IsNullOrEmpty(bomNumber) || Quantity != null)
            {
                //TODO：入参异常；
                throw new NotImplementedException("BOM编码或需求数量不能为空!");
            }
            //根据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 == false);

            //获取销售订单信息
            //var seorder = await _crm_seorder.FindAsync(x => x.Id == OrderId);
            var seorderentry = await _crm_seorderentry.FindAsync(x => x.Id == seorderentry_id);
            //获取物料详情
            var mysql_ic_item = await _mysql_ic_item.FindAsync(x => x.number == bomNumber);

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

            //首先满足需求数量工单其次判断是否满足交付日期、当数量不满足时继续查找最早交付日期订单 工单数量累加。
            //当前工单计划日期-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, mysql_ic_item, morder, mooccupies);
                await _mes_mooccupy.InsertOne(mes_Mooccupy);
            }
            else
            {
                // 寻找最早日期工单 &&  计算生产数量-入库数据并且大于需求产品数量后累加直到满足需求产品数量
                var morderListData = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();
                if (morderListData.Count == 0)
                {
                    //TODO：后期处理无在制工单返回内容
                    throw new NotImplementedException("无可用在制工单!");
                }
                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, mysql_ic_item, item, mooccupies);
                    mes_Mooccupies.Add(mes_Mooccupy);
                    //需求数量-占用量后小于或等于0 停止循环占用工单
                    if (number - mes_Mooccupy.moo_qty <= 0)
                    {
                        break;
                    }
                }
            }
            return morderList;
        }
        /// <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 mysql_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 = mysql_ic_item.name;//物料名称
            mes_Mooccupy.fitem_number = mysql_ic_item.number;
            mes_Mooccupy.fmodel = mysql_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;
            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 = 0;//TODO:企业ID =集团 或公司ID
            return mes_Mooccupy;
        }
        /// <summary>
        /// BOM预处理
        /// </summary>
        /// <param name="orderid"></param>
        /// <param name="BomId"></param>
        /// <param name="Quantity"></param>
        public void BomPretreatment(long? orderid, long? BomId, int Quantity)
        {
            if (orderid == null)
            {
                //throw new bu
            }
            if (BomId == null)
            {
                //throw new bu
            }

            //var query = (await _ic_bom.GetQueryableAsync()).WhereIf(true, a => a.bom_id == BomId).ToList();
            var help = new SnowFlake();
            var bomlist = _ic_bom.GetAll().Result;
            var bomchildlist = _ic_bom_child.GetAll().Result;
            var icitemlist = _ic_item.GetAll().Result;
            List<BomChildExamineDto> returnlist = new List<BomChildExamineDto>();
            var dto = new BomChildExamineDto();
            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);
        }

        /// <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++;//初始化定义level层级
            var help = new SnowFlake();

            var bom = bomlist.WhereIf(true, s => s.Id == dto.bom_id).FirstOrDefault();
            var item = icitemlist.WhereIf(true, a => a.Id == bom.icitem_id).FirstOrDefault();
            if (bom == null || item == null)
            {

            }
            dto.item_id = bom.icitem_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;
                    //递归寻找子级
                    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)
        {
            var sublist = _ic_substitute.GetManyByCondition(s => s.substitute_code.IsIn(returnlist.Select(c => c.substitute_code))).Result.ToList();
            var suballlist = _ic_substitute_all.GetManyByCondition(s => s.substitute_id.IsIn(sublist.Select(c => c.Id))).Result.ToList();
            var subdtllist = _ic_substitute_all_dtl.GetManyByCondition(s => s.substitute_allid.IsIn(suballlist.Select(c => c.Id))).Result.ToList();
            List<long> childidList = new List<long>();
            var help = new SnowFlake();
            int type = 1;
            //除顶级外，其他层级关系全带出来。生成平铺
            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();
                                foreach (var dtl in sadl)
                                {
                                    if (dtl.ismain == 0)
                                    {
                                        //递归将替代关系组装出来。
                                        SubstitutePretreatment(sl, sal, dtl, item, returnlist, icitemlist, bomlist, bomchildlist, type);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <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层级dto，明细
            //如果dtl对应的icitem是BOM，还需要向下继续展开。
            var help = new SnowFlake();

            //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.is_replace = 0;
            dto.haveicsubs = 0;
            dto.substitute_code = "";
            dto.icitem_ids = "";
            dto.substitute_strategy = sl.substitute_strategy.Value;//替代策略
            dto.substitute_mode = 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.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 orderid, long orderentryid, long factoryid)
        {
            returnlist = returnlist.OrderBy(s => s.num).ToList();
            //取物料库存记录
            FilterDefinition<ic_item_stock> filter = Builders<ic_item_stock>.Filter.In(s => s.icitem_id, returnlist.Select(c => c.item_id).ToList());
            var stocklist = _ic_item_stock.GetManyByIds(filter).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;
            }
        }

        /// <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 && s.type == 0).ToList();
            if (bomchild.Count > 0)
            {
                foreach (var child in bomchild)
                {
                    CaclBomChildUseShortage(returnlist, item);
                }
            }
            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.如果标准件不满足，则替代件开始计算并展示。
                //注意：不管是否需要替代件，标准件都需要展开。
                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找出当前含替代关系的标准件和替代件。

                


                if (item.substitute_mode == 0)
                {
                    //替代
                }
                else { 
                    //取代

                }
            }
            else
            {
                //无替代关系
                if (item.stock_state==0)
                {
                    item.use_qty = item.needCount;
                    item.is_show = true;
                    item.stock_state = 0;
                }
                else if (item.stock_state == 1)
                {
                    // 缺料数量 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);
                    }
                    else if (item.erp_cls == 1)
                    {
                        //自制
                        //调用产能计算，得到物料自制后的齐套时间。
                        //todo:初步设置为7天完成，等沟通调用方法，来修改此处。
                        item.kitting_time = DateTime.Now.AddDays(7);
                    }
                }
            }
        }

        /// <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;//5
            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
                    foreach (var child in childList)
                    {
                        //循环子集判断库存
                        CaclMaterialShortage(returnlist, child, count);
                    }
                }
                else
                {
                    item.stock_state = 1;
                }
            }
        }

    }
}