Merge branch 'master' of http://123.60.180.165:4647/ZZYDOP/DOPCore

MicroServices/Business/Business.Application.Contracts/ResourceExamineManagement/Dto/Mes_MorderDto.cs

@@ -0,0 +1,22 @@
+using Bussiness.Model.Production;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Business.ResourceExamineManagement.Dto
+{
+    public class Mes_MorderDto
+    {
+        /// <summary>
+        /// 工单主表
+        /// </summary>
+        public List<mes_morder> mes_Morders { get; set; }
+        /// <summary>
+        /// 工单子表
+        /// </summary>
+        public List<mes_moentry> mes_Moentries { get; set; }
+
+    }
+}

MicroServices/Business/Business.Application.Contracts/ScheduleTaskManagement/Dto/ResultDto.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Volo.Abp.Application.Dtos;
-using System.ComponentModel.DataAnnotations;
-namespace Business.ResourceExamineManagement.Dto
-{
-    /// <summary>
-    /// 数据同步返回结果Dto
-    /// </summary>
-    public class ResultDto
-    {
-        /// <summary>
-        /// 开始时间
-        /// </summary>
-        public DateTime start { get; set; }
-
-        /// <summary>
-        /// 结束时间
-        /// </summary>
-        public DateTime end { get; set; }
-
-        /// <summary>
-        /// 结果
-        /// </summary>
-        public bool isSuccess { get; set; }
-
-        /// <summary>
-        /// 异常信息
-        /// </summary>
-        public string msg { get; set; }
-    }
-}

MicroServices/Business/Business.Application.Contracts/ScheduleTaskManagement/IScheduleTaskAppService.cs

@@ -1,21 +0,0 @@
-using Business.ResourceExamineManagement.Dto;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Volo.Abp.Application.Dtos;
-using Volo.Abp.Application.Services;
-
-namespace Business.ScheduleTaskManagement
-{
-    /// <summary>
-    /// 同步数据
-    /// </summary>
-    public interface IScheduleTaskAppService : IApplicationService
-    {
-        /// <summary>
-        /// 同步基础数据到mongodb
-        /// </summary>
-        /// <returns></returns>
-        Task<ResultDto> SyncBaseDataToMongoDB();
-    }
-}

MicroServices/Business/Business.Application/HangFire/HangFireJobService.cs

@@ -1,4 +1,5 @@
-using System;
+using Business.SyncDataManagement;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -8,8 +9,25 @@ namespace Business.HangFire
 {
     public class HangFireJobService : IHangFireJobService
     {
-        public void SyncDataMySQLData()
+        /// <summary>
+        /// 同步数据到mongodb服务
+        /// </summary>
+        public readonly SyncMySQLDataAppService _syncDataAppservice;
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        public HangFireJobService(SyncMySQLDataAppService syncDataAppservice)
+        {
+            _syncDataAppservice = syncDataAppservice;
+        }
+
+        /// <summary>
+        /// 定时同步mysql数据到mongodb中
+        /// </summary>
+        public async void SyncDataMySQLData()
         {
+           await _syncDataAppservice.SyncBaseDataToMongoDB();
         }
     }
 }

MicroServices/Business/Business.Application/HangFire/IHangFireJobService.cs

@@ -8,6 +8,9 @@ namespace Business.HangFire
 {
     public interface IHangFireJobService
     {
+        /// <summary>
+        /// 定时同步mysql数据到mongodb中
+        /// </summary>
         void SyncDataMySQLData();
     }
 }

MicroServices/Business/Business.Application/ResourceExamineManagement/MorderAppService.cs

@@ -0,0 +1,286 @@
+using Business.Core.MongoDBHelper;
+using Business.ResourceExamineManagement.Dto;
+using Bussiness.Model.MES.IC;
+using Bussiness.Model.Production;
+using Bussiness.Model.Sale;
+using Bussiness.Model.SRM;
+using Bussiness.Model.Tech;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Volo.Abp.Application.Services;
+using Volo.Abp.Domain.Repositories;
+using ZstdSharp.Unsafe;
+
+namespace Business.ResourceExamineManagement
+{
+    public class MorderAppService : ApplicationService
+    {
+        #region 服务
+        /// <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>
+        /// 销售订单
+        /// </summary>
+        private readonly IRepository<crm_seorder, long> _mysql_crm_seorder;
+        /// <summary>
+        /// 销售订单明细
+        /// </summary>
+        private readonly IRepository<crm_seorderentry, long> _mysql_crm_seorderentry;
+
+        #endregion
+        #region 构造函数
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="icitem"></param>
+        /// <param name="icbom"></param>
+        public MorderAppService(
+            IMongoDB<mes_morder> mes_morder,
+            IMongoDB<mes_moentry> mes_moentry,
+            IMongoDB<mes_mooccupy> mes_mooccupy,
+            IRepository<crm_seorder, long> mysql_crm_seorder,
+            IRepository<crm_seorderentry, long> mysql_crm_seorderentry
+            )
+        {
+
+            _mes_morder = mes_morder;
+            _mes_moentry = mes_moentry;
+            _mes_mooccupy = mes_mooccupy;
+            _mysql_crm_seorder = mysql_crm_seorder;
+            _mysql_crm_seorderentry = mysql_crm_seorderentry;
+
+        }
+        #endregion
+
+        /// <summary>
+        /// 生成工单
+        /// </summary>
+        /// <param name="seorderentry">销售订单子表</param>
+        /// <param name="BomNumber">Bom编号</param>
+        /// <param name="version">Bom版本</param>
+        /// <param name="number">物料编码</param>
+        /// <param name="Quantity"></param>
+        /// <param name="ParentId"></param>
+        public Mes_MorderDto GenerateMorder(crm_seorderentry seorderentry, ic_item ic_Item, string BomNumber, string version, string number, decimal? Quantity, long? ParentId = null)
+        {
+            //1.库存、在制工单检查完成后 当前BOM需要自制时 产生工单。
+
+            //2.每一个销售订单行对应一个工单。
+            //TODO:考虑性能问题 循环调用,后期改造传递数组，批量处理数据后,批量保存。
+            //获取销售订单信息
+            var seorder = _mysql_crm_seorder.FindAsync(x => x.Id == seorderentry.seorder_id).Result;
+            //物料BOM
+            //var ic_bom = _ic_bom.GetManyByCondition(x => x.bom_number == BomNumber && x.factory_id == seorderentry.factory_id).Result.FirstOrDefault();
+            //物料详情
+            //var ic_item = _ic_item.GetManyByCondition(x => x.number == number && x.factory_id == seorderentry.factory_id).Result.FirstOrDefault();
+
+            mes_morder mes_Morder = new mes_morder();
+            mes_Morder.GenerateNewId();
+            mes_Morder.morder_type = "销售工单";
+            mes_Morder.parent_id = ParentId;
+            //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 = ic_Item.fms_number;
+            mes_Morder.bom_number = BomNumber;
+            mes_Morder.fmodel = ic_Item.model;
+            //最早的开工时间3天后、 最晚时间为订单承诺时间-采购提前期-质检提前期-入库提前期-发料提前期 =最晚开工时间  最早或最晚为系统建议开工日期
+            //根绝系统配置参数 取最早或者最晚开始日期
+            //var StartDate = DateTime.Now.Date.AddDays(3);
+            //mes_Morder.moentry_sys_stime = StartDate;
+            //if (!string.IsNullOrEmpty(BomNumber))
+            //{
+            //    var ProductiveDate = ProductiveExamine(BomNumber, version, (int)(Quantity.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 = number;
+            mes_Morder.product_name = ic_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 = ic_Item.unit;
+            mes_Morder.morder_production_number = Quantity;
+            mes_Morder.need_number = Quantity;
+            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 = ic_Item.unit;
+            mes_Moentry.morder_production_number = Quantity;
+            mes_Moentry.need_number = Quantity;
+            mes_Moentry.remaining_number = 0;
+            mes_Moentry.factory_id = seorderentry.factory_id;
+
+            Mes_MorderDto mes_MorderDto = new Mes_MorderDto();
+            mes_MorderDto.mes_Morders = new List<mes_morder>();
+            mes_MorderDto.mes_Moentries = new List<mes_moentry>();
+            mes_MorderDto.mes_Morders.Add(mes_Morder);
+            mes_MorderDto.mes_Moentries.Add(mes_Moentry);
+
+            return mes_MorderDto;
+
+            //using (TransactionScope scope = new TransactionScope())
+            // {
+            //_mes_morder.InsertOne(mes_Morder);
+            //_mes_moentry.InsertOne(mes_Moentry);
+            //scope.Complete();
+            //}
+        }
+
+        /// <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, ic_item ic_Item)
+        {
+            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;
+        }
+    }
+}

MicroServices/Business/Business.Application/ResourceExamineManagement/ProductExamineAppService.cs

@@ -0,0 +1,277 @@
+using Business.Core.MongoDBHelper;
+using Business.ResourceExamineManagement.Dto;
+using Bussiness.Model.Dto.ResExamin;
+using Bussiness.Model.Production;
+using Bussiness.Model.Tech;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Volo.Abp.Application.Services;
+using Volo.Abp.Domain.Repositories;
+
+namespace Business.ResourceExamineManagement
+{
+    /// <summary>
+    /// 产能检查
+    /// </summary>
+    public class ProductExamineAppService: ApplicationService
+    {
+        #region 服务
+        /// <summary>
+        /// 工艺路径
+        /// </summary>
+        private readonly IMongoDB<mes_technique> _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;
+        #endregion
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        public ProductExamineAppService(
+            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
+            )
+        {
+            _mes_technique = mes_technique;
+            _mes_process = mes_process;
+            _mes_tech_process = mes_tech_process;
+            _mes_tech_proc_workshop = mes_tech_proc_workshop;
+        }
+
+        /// <summary>
+        /// 产能计算
+        /// </summary>
+        /// <param name="param">产能检查入参</param>
+        /// <returns>生产时长</returns>
+        public async Task<decimal> ProductiveExamine(ProdExamineParamDto param)
+        {
+            if (param.packages <= 0)
+            {
+                throw new NotImplementedException("产能计算参数有误！");
+            }
+            #region 1、数据准备
+            //1.1、获取工艺路径数据
+            mes_technique tech = _mes_technique.Find(p => p.bom == param.bom_number && p.bomver == param.version && 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
+
+            //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.FirstOrDefault(p => p.nextprocid == null);
+            if (last == null)
+            {
+                throw new NotImplementedException("当前工艺路径没有配置最终工序，请调整！");
+            }
+            sortChilds.Add(last);
+            //递归按工序先后顺序排序
+            SortProcess(fistChilds, last.proc_id.Value, sortChilds);
+            //总耗时(分钟)
+            //decimal sumTimes = CalcTakeTimeByLq(sortChilds, param.packages);//通过Lq计算
+            decimal sumTimes = CalcTakeTimeByLqt(sortChilds, param.packages);//通过Lqt计算
+            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.proc_id.Value, sortProcesses);
+            }
+        }
+
+        /// <summary>
+        /// 通过Lq计算工艺耗时
+        /// </summary>
+        /// <param name="Processes"></param>
+        /// <param name="packages"></param>
+        /// <returns></returns>
+        private decimal CalcTakeTimeByLq(List<mes_tech_process> Processes, int packages)
+        {
+            decimal sumTimes = 0.00m;//总耗时(分钟)
+            //工序需要等待时间记录
+            List<StartTimeDto> starts = new List<StartTimeDto>();
+            StartTimeDto dto;
+            foreach (var chd in Processes)
+            {
+                dto = new StartTimeDto();
+                if (chd.nextprocid == null)//最后一个工序
+                {
+                    //计算最后一个工序耗时
+                    dto = CalcProcTakeTimeByLq(chd, packages, packages);
+                }
+                else
+                {
+                    dto = CalcProcTakeTimeByLq(chd, chd.lq.Value, packages);
+                }
+                sumTimes += dto.wait_time;
+                //添加记录
+                starts.Add(dto);
+            }
+            return sumTimes;
+        }
+
+        /// <summary>
+        /// 通过Lq计算当前工序前置准备时间
+        /// </summary>
+        /// <param name="proc"></param>
+        /// <param name="quantity">LeadQuantity to Start Next</param>
+        /// <param name="packages">件数</param>
+        /// <returns></returns>
+        private StartTimeDto CalcProcTakeTimeByLq(mes_tech_process proc, decimal quantity, int packages)
+        {
+            //记录当前工序耗时
+            StartTimeDto dto = new StartTimeDto();
+            //添加耗时记录
+            dto.tech_id = proc.tech_id.Value;
+            dto.proc_id = proc.proc_id.Value;
+            dto.nextproc_id = proc.nextprocid;
+            if (proc.wctype == 1)//人工型:数量/uph(一小时生产数量)*60(小时转换为分钟)/wsinuse(工位数)
+            {
+                dto.wait_time = quantity / proc.uph.Value * 60 / proc.wsinuse.Value;
+                dto.take_time = packages / proc.uph.Value * 60 / proc.wsinuse.Value;
+            }
+            else if (proc.wctype == 2)//流水线型:数量*ct(生产一件所需时间)/wsinuse(工位数)
+            {
+                dto.wait_time = quantity * proc.ct.Value / proc.wsinuse.Value;
+                dto.take_time = packages * proc.ct.Value / proc.wsinuse.Value;
+            }
+            else if (proc.wctype == 3)//设备型:向上取整(数量/一次可加工数量/wsinuse(工位数))*ct(老化一次所需时间)
+            {
+                dto.wait_time = Math.Ceiling(quantity / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
+                dto.take_time = Math.Ceiling(packages / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
+            }
+            return dto;
+        }
+
+        /// <summary>
+        /// 通过Lqt计算工艺耗时
+        /// </summary>
+        /// <param name="Processes"></param>
+        /// <param name="packages"></param>
+        /// <returns></returns>
+        private decimal CalcTakeTimeByLqt(List<mes_tech_process> Processes, int packages)
+        {
+            //总耗时
+            decimal sumTimes = 0;
+            //工序需要等待时间记录
+            List<StartTimeDto> starts = new List<StartTimeDto>();
+            StartTimeDto dto;
+            foreach (var chd in Processes)
+            {
+                dto = new StartTimeDto();
+                //添加耗时记录
+                dto.tech_id = chd.tech_id.Value;
+                dto.proc_id = chd.proc_id.Value;
+                dto.nextproc_id = chd.nextprocid;
+
+                //计算当前工序生产耗时
+                dto.take_time = CalcProcTakeTime(chd, packages);
+                if (chd.nextprocid == null)//最后一个工序
+                {
+                    dto.wait_time = dto.take_time;
+                }
+                else
+                {
+                    dto.wait_time = chd.lqt.Value;
+                }
+                sumTimes += dto.wait_time;
+                //添加记录
+                starts.Add(dto);
+            }
+            return sumTimes;
+        }
+
+        /// <summary>
+        /// 计算当前工序生产时间
+        /// </summary>
+        /// <param name="proc"></param>
+        /// <param name="packages">件数</param>
+        /// <returns></returns>
+        private decimal CalcProcTakeTime(mes_tech_process proc, int packages)
+        {
+            //当前工序生产时间
+            decimal takeTiem = 0.00m;
+
+            if (proc.wctype == 1)//人工型:数量/uph(一小时生产数量)*60(小时转换为分钟)/wsinuse(工位数)
+            {
+                takeTiem = packages / proc.uph.Value * 60 / proc.wsinuse.Value;
+            }
+            else if (proc.wctype == 2)//流水线型:数量*ct(生产一件所需时间)/wsinuse(工位数)
+            {
+                takeTiem = packages * proc.ct.Value / proc.wsinuse.Value;
+            }
+            else if (proc.wctype == 3)//设备型:向上取整(数量/一次可加工数量/wsinuse(工位数))*ct(老化一次所需时间)
+            {
+                takeTiem = Math.Ceiling(packages / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
+            }
+            return takeTiem;
+        }
+    }
+}

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

@@ -52,6 +52,7 @@ using Microsoft.EntityFrameworkCore.Migrations.Operations;
 using Microsoft.AspNetCore.SignalR;
 using System.Diagnostics;
 using Newtonsoft.Json;
+using Bussiness.Model.Dto.ResExamin;
 
 namespace Business.ResourceExamineManagement
 {
@@ -64,44 +65,6 @@ namespace Business.ResourceExamineManagement
         #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>
@@ -216,12 +179,10 @@ namespace Business.ResourceExamineManagement
         /// 销售订单
         /// </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>
         /// 生产工单主表
@@ -236,6 +197,15 @@ namespace Business.ResourceExamineManagement
         /// 资源检查入参
         /// </summary>
         private readonly SeorderentryDto param = new SeorderentryDto();
+
+        /// <summary>
+        /// 产能检查
+        /// </summary>
+        private readonly ProductExamineAppService _productExamineAppService;
+        /// <summary>
+        /// 工单App
+        /// </summary>
+        private readonly MorderAppService _morderAppService;
         #endregion
 
         #region 构造函数
@@ -245,10 +215,6 @@ namespace Business.ResourceExamineManagement
         /// <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,
@@ -259,8 +225,6 @@ namespace Business.ResourceExamineManagement
             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,
@@ -290,13 +254,11 @@ namespace Business.ResourceExamineManagement
             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
+            IRepository<ic_plan, long> mysql_ic_plan,
+            ProductExamineAppService productExamineAppService,
+            MorderAppService morderAppService
             )
         {
-            _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;
@@ -307,8 +269,6 @@ namespace Business.ResourceExamineManagement
             _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;
@@ -324,7 +284,6 @@ namespace Business.ResourceExamineManagement
             _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;
@@ -332,13 +291,13 @@ namespace Business.ResourceExamineManagement
             _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;
+            _productExamineAppService = productExamineAppService;
+            _morderAppService = morderAppService;
         }
         #endregion
 
@@ -373,7 +332,7 @@ namespace Business.ResourceExamineManagement
                 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);
+            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);
@@ -381,7 +340,7 @@ namespace Business.ResourceExamineManagement
             //通过订单行的产品代码获取物料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.item_number).Contains(p.item_number) && p.factory_id == input.factoryId && p.tenant_id == input.tenantId && !p.IsDeleted).Result.ToList();
+            List<ic_bom> boms = _ic_bom.Find(p => sentrys.Select(m => m.item_number).Contains(p.item_number) && p.factory_id == input.factoryId && p.tenant_id == input.tenantId && !p.IsDeleted).Result.ToList();
             //通过物料id获取产品提前期
             List<ICItemLeadTimeDto> leadTimes = GetLeadTime(boms.Select(p => p.icitem_id).ToList(), input.tenantId, input.factoryId);
 
@@ -407,9 +366,9 @@ namespace Business.ResourceExamineManagement
                 dtl.earliest_times = DateTime.Now.Date.AddDays(3);
 
                 //获取当前物料bom数据
-                var childBom = boms.Where(p => p.bom_number == item.bom_number).FirstOrDefault();
+                var childBom = boms.Where(p => p.item_number == item.item_number).FirstOrDefault();
                 //bom层级组装
-                var getBomList = BomPretreatment(item.Id, childBom.Id, item.qty.GetInt(), bomlist, bomchildlist, icitemlist);
+                var getBomList = BomPretreatment(childBom.Id, bomlist, bomchildlist, icitemlist);
                 //bom替代关系组装
                 BomSubstitute(getBomList, bomlist, bomchildlist, icitemlist);
                 //库存初始化
@@ -451,7 +410,7 @@ namespace Business.ResourceExamineManagement
             //添加物料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();
+            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)
             {
@@ -459,7 +418,7 @@ namespace Business.ResourceExamineManagement
             }
             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();
+            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();
@@ -506,20 +465,20 @@ namespace Business.ResourceExamineManagement
 
             //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_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 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;
@@ -570,462 +529,20 @@ namespace Business.ResourceExamineManagement
             }
         }
 
-        /// <summary>
-        /// 产能计算
-        /// </summary>
-        /// <param name="bom_number">bom编号</param>
-        /// <param name="version">版本号</param>
-        /// <param name="packages">需要生产产品件数</param>
-        /// <returns>生产时长</returns>
-        public async Task<decimal> ProductiveExamine(string bom_number, string version, int packages)
-        {
-            if (packages <= 0)
-            {
-                throw new NotImplementedException("产能计算参数有误！");
-            }
-            #region 1、数据准备
-            //1.1、获取工艺路径数据
-            mes_technique tech = _mes_technique.Find(p => p.bom == bom_number && p.bomver == version && 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
-
-            //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.FirstOrDefault(p => p.nextprocid == null);
-            if (last == null)
-            {
-                throw new NotImplementedException("当前工艺路径没有配置最终工序，请调整！");
-            }
-            sortChilds.Add(last);
-            //递归按工序先后顺序排序
-            SortProcess(fistChilds, last.proc_id.Value, sortChilds);
-            //总耗时(分钟)
-            //decimal sumTimes = CalcTakeTimeByLq(sortChilds, packages);//通过Lq计算
-            decimal sumTimes = CalcTakeTimeByLqt(sortChilds, packages);//通过Lqt计算
-            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.proc_id.Value, sortProcesses);
-            }
-        }
-
-        /// <summary>
-        /// 通过Lq计算工艺耗时
-        /// </summary>
-        /// <param name="Processes"></param>
-        /// <param name="packages"></param>
-        /// <returns></returns>
-        private decimal CalcTakeTimeByLq(List<mes_tech_process> Processes, int packages)
-        {
-            decimal sumTimes = 0.00m;//总耗时(分钟)
-            //工序需要等待时间记录
-            List<StartTimeDto> starts = new List<StartTimeDto>();
-            StartTimeDto dto;
-            foreach (var chd in Processes)
-            {
-                dto = new StartTimeDto();
-                if (chd.nextprocid == null)//最后一个工序
-                {
-                    //计算最后一个工序耗时
-                    dto = CalcProcTakeTimeByLq(chd, packages, packages);
-                }
-                else
-                {
-                    dto = CalcProcTakeTimeByLq(chd, chd.lq.Value, packages);
-                }
-                sumTimes += dto.wait_time;
-                //添加记录
-                starts.Add(dto);
-            }
-            return sumTimes;
-        }
-
-        /// <summary>
-        /// 通过Lq计算当前工序前置准备时间
-        /// </summary>
-        /// <param name="proc"></param>
-        /// <param name="quantity">LeadQuantity to Start Next</param>
-        /// <param name="packages">件数</param>
-        /// <returns></returns>
-        private StartTimeDto CalcProcTakeTimeByLq(mes_tech_process proc, decimal quantity, int packages)
-        {
-            //记录当前工序耗时
-            StartTimeDto dto = new StartTimeDto();
-            //添加耗时记录
-            dto.tech_id = proc.tech_id.Value;
-            dto.proc_id = proc.proc_id.Value;
-            dto.nextproc_id = proc.nextprocid;
-            if (proc.wctype == 1)//人工型:数量/uph(一小时生产数量)*60(小时转换为分钟)/wsinuse(工位数)
-            {
-                dto.wait_time = quantity / proc.uph.Value * 60 / proc.wsinuse.Value;
-                dto.take_time = packages / proc.uph.Value * 60 / proc.wsinuse.Value;
-            }
-            else if (proc.wctype == 2)//流水线型:数量*ct(生产一件所需时间)/wsinuse(工位数)
-            {
-                dto.wait_time = quantity * proc.ct.Value / proc.wsinuse.Value;
-                dto.take_time = packages * proc.ct.Value / proc.wsinuse.Value;
-            }
-            else if (proc.wctype == 3)//设备型:向上取整(数量/一次可加工数量/wsinuse(工位数))*ct(老化一次所需时间)
-            {
-                dto.wait_time = Math.Ceiling(quantity / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
-                dto.take_time = Math.Ceiling(packages / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
-            }
-            return dto;
-        }
-
-        /// <summary>
-        /// 通过Lqt计算工艺耗时
-        /// </summary>
-        /// <param name="Processes"></param>
-        /// <param name="packages"></param>
-        /// <returns></returns>
-        private decimal CalcTakeTimeByLqt(List<mes_tech_process> Processes, int packages)
-        {
-            //总耗时
-            decimal sumTimes = 0;
-            //工序需要等待时间记录
-            List<StartTimeDto> starts = new List<StartTimeDto>();
-            StartTimeDto dto;
-            foreach (var chd in Processes)
-            {
-                dto = new StartTimeDto();
-                //添加耗时记录
-                dto.tech_id = chd.tech_id.Value;
-                dto.proc_id = chd.proc_id.Value;
-                dto.nextproc_id = chd.nextprocid;
-
-                //计算当前工序生产耗时
-                dto.take_time = CalcProcTakeTime(chd, packages);
-                if (chd.nextprocid == null)//最后一个工序
-                {
-                    dto.wait_time = dto.take_time;
-                }
-                else
-                {
-                    dto.wait_time = chd.lqt.Value;
-                }
-                sumTimes += dto.wait_time;
-                //添加记录
-                starts.Add(dto);
-            }
-            return sumTimes;
-        }
-
-        /// <summary>
-        /// 计算当前工序生产时间
-        /// </summary>
-        /// <param name="proc"></param>
-        /// <param name="packages">件数</param>
-        /// <returns></returns>
-        private decimal CalcProcTakeTime(mes_tech_process proc, int packages)
-        {
-            //当前工序生产时间
-            decimal takeTiem = 0.00m;
-            
-            if (proc.wctype == 1)//人工型:数量/uph(一小时生产数量)*60(小时转换为分钟)/wsinuse(工位数)
-            {
-                takeTiem = packages / proc.uph.Value * 60 / proc.wsinuse.Value;
-            }
-            else if (proc.wctype == 2)//流水线型:数量*ct(生产一件所需时间)/wsinuse(工位数)
-            {
-                takeTiem = packages * proc.ct.Value / proc.wsinuse.Value;
-            }
-            else if (proc.wctype == 3)//设备型:向上取整(数量/一次可加工数量/wsinuse(工位数))*ct(老化一次所需时间)
-            {
-                takeTiem = Math.Ceiling(packages / proc.upe.Value / proc.wsinuse.Value) * proc.ct.Value;
-            }
-            return takeTiem;
-        }
-
-        /// <summary>
-        /// 生成工单
-        /// </summary>
-        /// <param name="seorderentry">销售订单子表</param>
-        /// <param name="BomNumber">Bom编号</param>
-        /// <param name="version">Bom版本</param>
-        /// <param name="number">物料编码</param>
-        /// <param name="Quantity"></param>
-        /// <param name="ParentId"></param>
-        public void GenerateMorder(crm_seorderentry seorderentry, string BomNumber,string version, string number, decimal? Quantity, long? ParentId=null)
-        {
-            //1.库存、在制工单检查完成后 当前BOM需要自制时 产生工单。
-
-            //2.每一个销售订单行对应一个工单。
-            //TODO:考虑性能问题 循环调用,后期改造传递数组，批量处理数据后,批量保存。
-            //获取销售订单信息
-            var seorder = _mysql_crm_seorder.FindAsync(x => x.Id == seorderentry.seorder_id).Result;
-            //物料BOM
-            //var ic_bom = _ic_bom.GetManyByCondition(x => x.bom_number == BomNumber && x.factory_id == seorderentry.factory_id).Result.FirstOrDefault();
-            //物料详情
-            var ic_item = _ic_item.GetManyByCondition(x => x.number == number && x.factory_id == seorderentry.factory_id).Result.FirstOrDefault();
-
-            mes_morder mes_Morder = new mes_morder();
-            mes_Morder.GenerateNewId();
-            mes_Morder.morder_type = "销售工单";
-            mes_Morder.parent_id = ParentId;
-            //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 = ic_item.fms_number;
-            mes_Morder.bom_number = BomNumber;
-            mes_Morder.fmodel = ic_item.model;
-            //最早的开工时间3天后、 最晚时间为订单承诺时间-采购提前期-质检提前期-入库提前期-发料提前期 =最晚开工时间  最早或最晚为系统建议开工日期
-            //根绝系统配置参数 取最早或者最晚开始日期
-            var StartDate = DateTime.Now.Date.AddDays(3);
-            mes_Morder.moentry_sys_stime = StartDate;
-            if (!string.IsNullOrEmpty(BomNumber))
-            {
-                var ProductiveDate = ProductiveExamine(BomNumber, version,(int)(Quantity.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 = number;
-            mes_Morder.product_name = ic_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 = ic_item.unit;
-            mes_Morder.morder_production_number = Quantity;
-            mes_Morder.need_number = Quantity;
-            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 = ic_item.unit;
-            mes_Moentry.morder_production_number = Quantity;
-            mes_Moentry.need_number = Quantity;
-            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)
+        public List<BomChildExamineDto> BomPretreatment(long? BomId, 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 bom = bomlist.Find(s => s.Id == BomId);
             if (bom == null)
             {
@@ -1347,7 +864,7 @@ namespace Business.ResourceExamineManagement
             //先处理下最顶级的产品需要数量
             returnlist[0].needCount = returnlist[0].qty * count;
             returnlist[0].lack_qty = returnlist[0].needCount - returnlist[0].sqty;
-            
+
             foreach (var item in returnlist)
             {
                 if (item.level == 1)
@@ -1357,12 +874,15 @@ namespace Business.ResourceExamineManagement
                 //循环平铺整个资源检查的物料库存情况、缺料情况，子集缺料需要用父级缺料*子集使用数量-
                 CaclMaterialShortage(returnlist, item, count);
             }
-
+            Mes_MorderDto mes_MorderDto = new Mes_MorderDto();
             if (returnlist[0].lack_qty > 0)
             {
                 var seorderentry = _mysql_crm_seorderentry.FindAsync(x => x.Id == orderid).Result;
+
+                //获取物料详情
+                var ic_item = _ic_item.GetManyByCondition(x => x.number == seorderentry.item_number && x.tenant_id == seorderentry.tenant_id).Result.FirstOrDefault();
                 //生成主工单
-                GenerateMorder(seorderentry, returnlist[0].bom_number, returnlist[0].version, returnlist[0].item_number, returnlist[0].lack_qty);
+                mes_MorderDto = _morderAppService.GenerateMorder(seorderentry, ic_item, returnlist[0].bom_number, returnlist[0].version, returnlist[0].item_number, returnlist[0].lack_qty);
             }
 
             //这是从上往下展开计算缺料和可制
@@ -1372,7 +892,38 @@ namespace Business.ResourceExamineManagement
             CalcIcitem(childList, returnlist, bangid, orderid, input, sklist, plan_date);
             returnlist[0].kitting_time = childList.Max(s => s.kitting_time);
             //这里更新产品得满足时间。
-
+            if (mes_MorderDto != null)
+            {
+                //TODO:目前不考虑子工单 只存在单条数据先这样取值；
+                var mes_Morders = mes_MorderDto.mes_Morders.FirstOrDefault();
+                var mes_Moentry = mes_MorderDto.mes_Moentries.FirstOrDefault();
+                if (mes_Morders != null)
+                {
+                    mes_Morders.moentry_sys_stime = returnlist[0].kitting_time;
+                    if (!string.IsNullOrEmpty(mes_Morders.bom_number))
+                    {
+                        //var ProductiveDate = ProductiveExamine(mes_Morders.bom_number, returnlist[0].version, (int)mes_Morders.morder_production_number.Value);
+                        ProdExamineParamDto prodExamine = new ProdExamineParamDto()
+                        {
+                            bom_number = mes_Morders.bom_number,
+                            version = returnlist[0].version,
+                            packages = (int)mes_Morders.morder_production_number.Value,
+                            tenantId = param.tenantId,
+                            factoryId = param.factoryId
+
+                        };
+                        var ProductiveDate = _productExamineAppService.ProductiveExamine(prodExamine);
+                        //系统建议完工日期为 开工日期+产能检查时间=完工日期
+                        var Day = ProductiveDate.Result / (60 * 10); //返回的分钟除以十个小时得出工作天数；
+                        mes_Morders.moentry_sys_etime = returnlist[0].kitting_time.Value.AddDays((double)Day);
+                        mes_Morders.morder_need_time = ProductiveDate.Result;
+                        returnlist[0].satisfy_time = mes_Morders.moentry_sys_etime;
+                    }
+                    //批量保存 后期考虑子工单
+                    _mes_morder.InsertMany(mes_MorderDto.mes_Morders);
+                    _mes_moentry.InsertMany(mes_MorderDto.mes_Moentries);
+                }
+            }
         }
 
         /// <summary>
@@ -1385,7 +936,7 @@ namespace Business.ResourceExamineManagement
         /// <param name="input"></param>
         /// <param name="sklist"></param>
         /// <param name="plan_date"></param>
-        public  void CalcIcitem(List<BomChildExamineDto> childList, List<BomChildExamineDto> returnlist, long bangid, long orderid, SeorderentryDto input, List<ic_item_stockoccupy> sklist, DateTime
+        public void CalcIcitem(List<BomChildExamineDto> childList, List<BomChildExamineDto> returnlist, long bangid, long orderid, SeorderentryDto input, List<ic_item_stockoccupy> sklist, DateTime
             ? plan_date)
         {
             foreach (var item in childList)
@@ -1423,7 +974,17 @@ namespace Business.ResourceExamineManagement
                         if (item.erp_cls == 1)
                         {
                             //走自制
-                            var minute = ProductiveExamine(item.bom_number,"1.0", item.lack_qty.GetInt());
+                            //var minute = ProductiveExamine(item.bom_number, "1.0", item.lack_qty.GetInt());
+                            ProdExamineParamDto prodExamine = new ProdExamineParamDto()
+                            {
+                                bom_number = item.bom_number,
+                                version = item.version,
+                                packages = item.lack_qty.GetInt(),
+                                tenantId = param.tenantId,
+                                factoryId = param.factoryId
+
+                            };
+                            var minute = _productExamineAppService.ProductiveExamine(prodExamine);
                             //var ProductiveDate = ProductiveExamine(BomNumber, (int)(Quantity.Value));
                             //系统建议完工日期为 开工日期+产能检查时间=完工日期
                             var Day = minute.Result / (60 * 10); //返回的分钟除以十个小时得出工作天数；
@@ -1446,7 +1007,8 @@ namespace Business.ResourceExamineManagement
                             }
                         }
                     }
-                    else {
+                    else
+                    {
                         item.use_qty = 0;
                         if (parent.stock_state == 1)
                         {
@@ -1458,7 +1020,7 @@ namespace Business.ResourceExamineManagement
                     }
                     item.is_use = true;
 
-                    
+
                 }
             }
         }
@@ -1630,7 +1192,17 @@ namespace Business.ResourceExamineManagement
                     {
                         slt.make_qty = slt.lack_qty;
                         //走自制
-                        var minute = ProductiveExamine(item.bom_number, "1.0", item.lack_qty.GetInt());
+                        //var minute = ProductiveExamine(item.bom_number, "1.0", item.lack_qty.GetInt());
+                        ProdExamineParamDto prodExamine = new ProdExamineParamDto()
+                        {
+                            bom_number = item.bom_number,
+                            version = item.version,
+                            packages = item.lack_qty.GetInt(),
+                            tenantId = param.tenantId,
+                            factoryId = param.factoryId
+
+                        };
+                        var minute = _productExamineAppService.ProductiveExamine(prodExamine);
                         //系统建议完工日期为 开工日期+产能检查时间=完工日期
                         var Day = minute.Result / (60 * 10); //返回的分钟除以十个小时得出工作天数；
                         slt.kitting_time = slt.kitting_time.Value.AddDays((double)Day);
@@ -1847,7 +1419,7 @@ namespace Business.ResourceExamineManagement
                 {
                     //根据占用情况计算库存
                     Calczykc(item, parent, sockoccupyList);
-                    
+
                     //如果有子集，则丢入循环，判断下库存可制等信息。
                     calcTest2(item, childList, returnlist, sockoccupyList);
                     /*item.kz = childList.Min(s => s.kz);
@@ -1953,7 +1525,8 @@ namespace Business.ResourceExamineManagement
                 item.stock_state = parent.stock_state;
                 item.lack_qty = 0;
             }
-            else {
+            else
+            {
                 //判断缺料数量
                 item.lack_qty = parent.lack_qty * item.qty - item.sqty;
                 //判断状态
@@ -2315,7 +1888,7 @@ namespace Business.ResourceExamineManagement
             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)
+            if (leadTime == null || supplier == null || plan == null)
             {
                 throw new NotImplementedException("未找到物料ic_factory_details或ic_item_pur或ic_plan信息！");
             }

MicroServices/Business/Business.Application/ScheduleTaskManagement/ScheduleTaskAppService.cs → MicroServices/Business/Business.Application/SyncDataManagement/SyncMySQLDataAppService.cs

@@ -47,12 +47,12 @@ using System.Collections;
 using System.Data.SqlTypes;
 using Bussiness.Model.SystemData;
 
-namespace Business.ScheduleTaskManagement
+namespace Business.SyncDataManagement
 {
     /// <summary>
-    /// 资源检查
+    /// 同步mysql数据到mongodb
     /// </summary>
-    public class ScheduleTaskAppService : ApplicationService, IScheduleTaskAppService
+    public class SyncMySQLDataAppService : ApplicationService
     {
         #region 服务
         /// <summary>
@@ -119,7 +119,7 @@ namespace Business.ScheduleTaskManagement
         /// <summary>
         /// 构造函数
         /// </summary>
-        public ScheduleTaskAppService(
+        public SyncMySQLDataAppService(
             IMongoDB<ic_bom> ic_bom,
             IMongoDB<ic_bom_child> ic_bom_child,
             IMongoDB<ic_item> ic_item,
@@ -169,123 +169,106 @@ namespace Business.ScheduleTaskManagement
         /// </summary>
         /// <returns></returns>
         /// <exception cref="NotImplementedException"></exception>
-        public async Task<ResultDto> SyncBaseDataToMongoDB()
+        public async Task SyncBaseDataToMongoDB()
         {
-            //数据同步返回结果
-            ResultDto result = new ResultDto();
-            result.start = DateTime.Now;
-            try
+            //同步物料Bom数据
+            var icBoms = await _mysql_ic_bom.GetListAsync();
+            if (icBoms.Count > 0)
             {
-                //同步物料Bom数据
-                var icBoms = await _mysql_ic_bom.GetListAsync();
-                if (icBoms.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _ic_bom.DeleteAll();
-                    //插入数据
-                    await _ic_bom.InsertMany(icBoms);
-                }
-
-                //同步物料BOM明细数据
-                var icbom_childs = await _mysql_ic_bom_child.GetListAsync();
-                if (icbom_childs.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _ic_bom_child.DeleteAll();
-                    //插入数据
-                    await _ic_bom_child.InsertMany(icbom_childs);
-                }
-
-                //同步物料数据
-                var icItems = await _mysql_ic_item.GetListAsync();
-                if (icItems.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _ic_item.DeleteAll();
-                    //插入数据
-                    await _ic_item.InsertMany(icItems);
-                }
+                //先清空表数据(删除mongodb中的集合)
+                await _ic_bom.DeleteAll();
+                //插入数据
+                await _ic_bom.InsertMany(icBoms);
+            }
 
-                //同步替代群组数据
-                var subtitutes = await _mysql_ic_substitute.GetListAsync();
-                if (subtitutes.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _ic_substitute.DeleteAll();
-                    //插入数据
-                    await _ic_substitute.InsertMany(subtitutes);
-                }
+            //同步物料BOM明细数据
+            var icbom_childs = await _mysql_ic_bom_child.GetListAsync();
+            if (icbom_childs.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _ic_bom_child.DeleteAll();
+                //插入数据
+                await _ic_bom_child.InsertMany(icbom_childs);
+            }
 
-                //同步物料替代多群组数据
-                var subAlls = await _mysql_ic_substitute_all.GetListAsync();
-                if (subAlls.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _ic_substitute_all.DeleteAll();
-                    //插入数据
-                    await _ic_substitute_all.InsertMany(subAlls);
-                }
+            //同步物料数据
+            var icItems = await _mysql_ic_item.GetListAsync();
+            if (icItems.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _ic_item.DeleteAll();
+                //插入数据
+                await _ic_item.InsertMany(icItems);
+            }
 
-                //同步物料替代多群组明细数据
-                var subAllDtls = await _mysql_ic_substitute_all_dtl.GetListAsync();
-                if (subAllDtls.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _ic_substitute_all_dtl.DeleteAll();
-                    //插入数据
-                    await _ic_substitute_all_dtl.InsertMany(subAllDtls);
-                }
+            //同步替代群组数据
+            var subtitutes = await _mysql_ic_substitute.GetListAsync();
+            if (subtitutes.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _ic_substitute.DeleteAll();
+                //插入数据
+                await _ic_substitute.InsertMany(subtitutes);
+            }
 
-                //同步供应商数据
-                var suppliers = await _mysql_srm_supplier.GetListAsync();
-                if (suppliers.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _srm_supplier.DeleteAll();
-                    //插入数据
-                    await _srm_supplier.InsertMany(suppliers);
-                }
+            //同步物料替代多群组数据
+            var subAlls = await _mysql_ic_substitute_all.GetListAsync();
+            if (subAlls.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _ic_substitute_all.DeleteAll();
+                //插入数据
+                await _ic_substitute_all.InsertMany(subAlls);
+            }
 
-                //同步工艺路径数据
-                var techs = await _mysql_mes_technique.GetListAsync();
-                if (techs.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _mes_technique.DeleteAll();
-                    //插入数据
-                    await _mes_technique.InsertMany(techs);
-                }
+            //同步物料替代多群组明细数据
+            var subAllDtls = await _mysql_ic_substitute_all_dtl.GetListAsync();
+            if (subAllDtls.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _ic_substitute_all_dtl.DeleteAll();
+                //插入数据
+                await _ic_substitute_all_dtl.InsertMany(subAllDtls);
+            }
 
-                //同步工序数据
-                var processes = await _mysql_mes_process.GetListAsync();
-                if (suppliers.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _mes_process.DeleteAll();
-                    //插入数据
-                    await _mes_process.InsertMany(processes);
-                }
+            //同步供应商数据
+            var suppliers = await _mysql_srm_supplier.GetListAsync();
+            if (suppliers.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _srm_supplier.DeleteAll();
+                //插入数据
+                await _srm_supplier.InsertMany(suppliers);
+            }
 
-                //同步工艺关联工序数据
-                var tech_procs = await _mysql_mes_tech_process.GetListAsync();
-                if (tech_procs.Count > 0)
-                {
-                    //先清空表数据(删除mongodb中的集合)
-                    await _mes_tech_process.DeleteAll();
-                    //插入数据
-                    await _mes_tech_process.InsertMany(tech_procs);
-                }
+            //同步工艺路径数据
+            var techs = await _mysql_mes_technique.GetListAsync();
+            if (techs.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _mes_technique.DeleteAll();
+                //插入数据
+                await _mes_technique.InsertMany(techs);
+            }
 
-                result.end = DateTime.Now;
-                result.isSuccess = true;
-                return result;
+            //同步工序数据
+            var processes = await _mysql_mes_process.GetListAsync();
+            if (suppliers.Count > 0)
+            {
+                //先清空表数据(删除mongodb中的集合)
+                await _mes_process.DeleteAll();
+                //插入数据
+                await _mes_process.InsertMany(processes);
             }
-            catch (Exception ex)
+
+            //同步工艺关联工序数据
+            var tech_procs = await _mysql_mes_tech_process.GetListAsync();
+            if (tech_procs.Count > 0)
             {
-                result.end = DateTime.Now;
-                result.isSuccess = false;
-                result.msg = ex.Message;
-                return result;
+                //先清空表数据(删除mongodb中的集合)
+                await _mes_tech_process.DeleteAll();
+                //插入数据
+                await _mes_tech_process.InsertMany(tech_procs);
             }
         }
     }

MicroServices/Business/Business.HttpApi/Controllers/ScheduleTaskController.cs

@@ -1,39 +0,0 @@
-using Business.ResourceExamineManagement.Dto;
-using Business.ScheduleTaskManagement;
-using Microsoft.AspNetCore.Mvc;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Volo.Abp;
-using Volo.Abp.AspNetCore.Mvc;
-
-namespace Business.Controllers
-{
-    /// <summary>
-    /// 同步数据
-    /// </summary>
-    [RemoteService]
-    [Area("Business")]
-    [Route("api/business/schedule-task")]
-    public class ScheduleTaskController : AbpController
-    {
-        private readonly IScheduleTaskAppService _ScheduleTaskAppService;
-
-        public ScheduleTaskController(IScheduleTaskAppService ScheduleTaskAppService)
-        {
-            _ScheduleTaskAppService = ScheduleTaskAppService;
-        }
-
-        /// <summary>
-        /// 同步基础数据到mongodb
-        /// </summary>
-        /// <returns></returns>
-        [HttpGet]
-        public Task<ResultDto> SyncBaseDataToMongoDB()
-        {
-            return _ScheduleTaskAppService.SyncBaseDataToMongoDB();
-        }
-    }
-}

MicroServices/Business/Bussiness.Model/Dto/ResExamin/ProdExamineParamDto.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Bussiness.Model.Dto.ResExamin
+{
+    /// <summary>
+    /// 产能检查入参Dto
+    /// </summary>
+    public class ProdExamineParamDto
+    {
+        /// <summary>
+        /// bom编号
+        /// </summary>
+        public string? bom_number { get; set; }
+
+        /// <summary>
+        /// bom版本
+        /// </summary>
+        public string? version { get; set; }
+
+        /// <summary>
+        /// 生产件数
+        /// </summary>
+        public int packages { get; set; }
+
+        /// <summary>
+        /// 企业id
+        /// </summary>
+        public long tenantId { get; set; }
+
+        /// <summary>
+        /// 工厂id
+        /// </summary>
+        public long factoryId { get; set; }
+    }
+}

MicroServices/Business/Bussiness.Model/MES/IC/ic_bom_child.cs

@@ -145,6 +145,13 @@ namespace Bussiness.Model.MES.IC
         /// </summary>
         [Description("序号")]
         public int child_num { get; set; }
+
+        /// <summary>
+        /// 版本
+        /// </summary>
+        [StringLength(80)]
+        [Description("版本")]
+        public string? version { get; set; }
     }
 }