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

using Business.Core.Enum;
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 Bussiness.MongoModel.MES.IC;
using Bussiness.MongoModel.Production;
using Bussiness.MongoModel.Sale;
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;
        /// <summary>
        /// 产能检查
        /// </summary>
        private readonly ProductExamineAppService _productExamineAppService;

        #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,
            ProductExamineAppService productExamineAppService
            )
        {

            _mes_morder = mes_morder;
            _mes_moentry = mes_moentry;
            _mes_mooccupy = mes_mooccupy;
            _mysql_crm_seorder = mysql_crm_seorder;
            _mysql_crm_seorderentry = mysql_crm_seorderentry;
            _productExamineAppService = productExamineAppService;

        }
        #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(GenerateMorderDto generateMorderDto)
        {
            //1.库存、在制工单检查完成后 当前BOM需要自制时 产生工单。

            //2.每一个销售订单行对应一个工单。
            //TODO:考虑性能问题 循环调用,后期改造传递数组，批量处理数据后,批量保存。
            //获取销售订单信息
            var seorder = _mysql_crm_seorder.FindAsync(x => x.Id == generateMorderDto.seorderentry.seorder_id).Result;

            mo_mes_morder mes_Morder = new mo_mes_morder();
            mes_Morder.GenerateNewId();
            mes_Morder.morder_type = generateMorderDto.morder_type;
            mes_Morder.parent_id = generateMorderDto.ParentId;
            //mes_Morder.morder_icitem_type
            mes_Morder.work_order_type = generateMorderDto.work_order_type;
            mes_Morder.morder_state = generateMorderDto.morder_state;
            mes_Morder.morder_no = string.Format("VMO{0}", DateTime.Now.ToString("yyyyMMddhhmmss"));//测试编码
            mes_Morder.fms_number = generateMorderDto.ic_Item.fms_number;
            mes_Morder.bom_number = generateMorderDto.BomNumber;
            mes_Morder.fmodel = generateMorderDto.ic_Item.model;
            if (generateMorderDto.ParentId != null && generateMorderDto.moentry_sys_stime != null)
            {
                //最早的开工时间3天后、 最晚时间为订单承诺时间 - 采购提前期 - 质检提前期 - 入库提前期 - 发料提前期 = 最晚开工时间  最早或最晚为系统建议开工日期
                //var StartDate = DateTime.Now.Date.AddDays(3);
                mes_Morder.moentry_sys_stime = generateMorderDto.moentry_sys_stime;
                if (!string.IsNullOrEmpty(generateMorderDto.BomNumber))
                {
                    ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                    {
                        bom_number = generateMorderDto.BomNumber,
                        version = generateMorderDto.version,
                        packages = (int)generateMorderDto.Quantity.GetValueOrDefault(),
                        tenantId = generateMorderDto.seorderentry.tenant_id,
                        factoryId = generateMorderDto.seorderentry.factory_id.GetValueOrDefault()
                    };
                    var ProductiveDate = _productExamineAppService.ProductiveExamine(prodExamine);
                    //系统建议完工日期为 开工日期+产能检查时间=完工日期
                    var Day = ProductiveDate.Result / (60 * 10); //返回的分钟除以十个小时得出工作天数；
                    mes_Morder.moentry_sys_etime = mes_Morder.moentry_sys_stime.GetValueOrDefault().AddDays((double)Day);
                    mes_Morder.morder_need_time = ProductiveDate.Result;
                }
            }

            mes_Morder.moentry_startup_status = 0;
            mes_Morder.tenant_id = generateMorderDto.seorderentry.tenant_id;
            mes_Morder.factory_id = generateMorderDto.seorderentry.factory_id;
            mes_Morder.product_code = generateMorderDto.number;
            mes_Morder.product_name = generateMorderDto.ic_Item.name;
            mes_Morder.project_name = seorder.project_name;
            mes_Morder.planner_num = generateMorderDto.seorderentry.planner_no;
            mes_Morder.planner_name = generateMorderDto.seorderentry.planner_name;
            mes_Morder.morder_date = DateTime.Now.Date.AddDays(1);
            //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 = generateMorderDto.ic_Item.unit;
            mes_Morder.morder_production_number = generateMorderDto.Quantity;
            mes_Morder.need_number = generateMorderDto.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 = generateMorderDto.seorderentry.Id;
            mes_Moentry.fbill_no = generateMorderDto.seorderentry.bill_no;
            mes_Moentry.fentry_id = generateMorderDto.seorderentry.entry_seq.Value;
            mes_Moentry.unit = generateMorderDto.ic_Item.unit;
            mes_Moentry.morder_production_number = generateMorderDto.Quantity;
            mes_Moentry.need_number = generateMorderDto.Quantity;
            mes_Moentry.remaining_number = 0;
            mes_Moentry.factory_id = generateMorderDto.seorderentry.factory_id;

            Mes_MorderDto mes_MorderDto = new Mes_MorderDto();
            mes_MorderDto.mes_Morders = new List<mo_mes_morder>();
            mes_MorderDto.mes_Moentries = new List<mo_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<List<mo_mes_mooccupy>> CheckMorder(string bomNumber, decimal Quantity, DateTime DeliverDate, mo_crm_seorderentry seorderentry, mo_ic_item ic_Item, bool flag = true)
        {
            if (string.IsNullOrEmpty(bomNumber))
            {
                //TODO：入参异常；
                return null;
            }
            //获取销售订单信息
            //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 != MorderEnum.Accomplish_state || x.morder_state != MorderEnum.Close_state
            && x.morder_icitem_type != MorderEnum.XgwyMorder) && !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
            && x.fitem_number == ic_Item.number);

            //首先满足需求数量工单其次判断是否满足交付日期、当数量不满足时继续查找最早交付日期订单 工单数量累加。
            //当前工单计划日期-1天 小于交付日期 && 计算生产数量-入库数据并且大于需求产品数量。
            var morderDataList = morderList.Where(x => x.moentry_sys_etime.GetValueOrDefault().AddDays(-1) < DeliverDate &&
            (x.morder_production_number - x.inventory_number) > Quantity).OrderByDescending(x => x.planner_end_date).ToList();
            List<mes_mooccupy> mes_Mooccupies = new List<mes_mooccupy>();
            //当数量或日期不满足的时候，寻找最早日期的工单
            if (morderDataList.Count == 0)
            {
                morderDataList = morderList.Where(x => x.moentry_sys_etime.GetValueOrDefault().AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();
            }
            var QuantityNumber = 0.00m;
            //存在此数据满足当前BOM交付找到最早日期工单，则返回无需后续继续检查。
            foreach (var item in morderDataList)
            {
                //查询当前工单是否存在占用情况
                var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();
                //已占用数据
                var Sumqty = mooccupies.Count > 0 ? mooccupies.Sum(x => x.moo_qty) : 0.00m;
                //判断此工单剩余可占用数量
                if (item.morder_production_number - item.inventory_number - Sumqty > 0)
                {
                    #region 注释
                    //if (Sumqty > 0 || item.inventory_number > 0)
                    //{
                    //    ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                    //    {
                    //        bom_number = item.bom_number,
                    //        version = version,
                    //        packages = (int)(item.inventory_number + Sumqty).GetValueOrDefault(),
                    //        tenantId = item.tenant_id,
                    //        factoryId = item.factory_id.GetValueOrDefault()

                    //    };
                    //    //获取入库和已占用的数据的生产时长
                    //    var ProductiveDate = _productExamineAppService.ProductiveExamine(prodExamine);
                    //    var Day = ProductiveDate.Result / (60 * 10);
                    //    //工单被完全占用结束日期为工单结束时间
                    //    if (Quantity - (item.morder_production_number - item.inventory_number - Sumqty) == 0)
                    //    {

                    //        var date = item.moentry_sys_stime.GetValueOrDefault().AddDays((double)Day);
                    //        var endDate = item.moentry_sys_etime;
                    //    }
                    //    //工单未被完成占用计算结束日期
                    //    else if (item.morder_production_number - item.inventory_number - Sumqty - Quantity > 0)
                    //    {
                    //        var date = item.moentry_sys_stime.GetValueOrDefault().AddDays((double)Day);
                    //        ProdExamineParamDto EndprodExamine = new ProdExamineParamDto()
                    //        {
                    //            bom_number = item.bom_number,
                    //            version = version,
                    //            packages = (int)Quantity.GetValueOrDefault(),
                    //            tenantId = item.tenant_id,
                    //            factoryId = item.factory_id.GetValueOrDefault()

                    //        };
                    //        var EndProductiveDate = _productExamineAppService.ProductiveExamine(EndprodExamine);
                    //        var EndDay = ProductiveDate.Result / (60 * 10);
                    //        var endDate = date.AddDays((double)EndDay);
                    //    }

                    //}

                    #endregion
                    var Sum = item.morder_production_number - item.inventory_number - Sumqty;
                    //工单可占用数量-需求数量小于0时 占用工单全部可占用数量
                    if (Sum - Quantity <= 0)
                    {
                        QuantityNumber = Sum.GetValueOrDefault();
                    }
                    else
                    {
                        //工单可占用数量满足 需求数量时直接占用需求数量
                        QuantityNumber = Quantity;
                    }
                    var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, QuantityNumber);
                    mes_Mooccupies.Add(mes_Mooccupy);
                    //当剩余需要数量大于0则继续寻找可占用工单，已满足需要数量停止循环查找
                    if (Quantity - Sum <= 0)
                    {
                        break;
                    }
                    Quantity = Quantity - Sum.GetValueOrDefault();
                }

            }
            #region 注释
            //  if (morderDataList.Count > 0)
            //  {
            //      //存在此数据满足当前BOM交付找到最早日期工单，则返回无需后续继续检查。
            //      var morder = morderDataList.OrderByDescending(x => x.planner_end_date);
            //      foreach (var item in morder)
            //      {
            //          var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();
            //          if (mooccupies.Count > 0)
            //          {
            //              var Sumqty = mooccupies.Sum(x => x.moo_qty);
            //              //判断此工单剩下数量是否还有
            //              if (item.morder_production_number - item.inventory_number - Sumqty > 0)
            //              {
            //                  var Sum = item.morder_production_number - item.inventory_number - Sumqty;
            //                  //需要数量-（计划数量-入库数量-已占用量）
            //                  Quantity = Quantity - (item.morder_production_number - item.inventory_number - Sumqty);
            //                  if (Quantity > 0)
            //                  {
            //                      var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, Sum);
            //                      mes_Mooccupies.Add(mes_Mooccupy);
            //                  }
            //                  else
            //                  {
            //                      break;
            //                  }
            //              }
            //          }
            //      }
            //      await _mes_mooccupy.InsertMany(mes_Mooccupies);
            //      Number = 1;
            //  }
            //  else
            //  {
            //      // 寻找最早日期工单 &&  计算生产数量-入库数据并且大于需求产品数量后累加直到满足需求产品数量
            //      var morderListData = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();

            //      decimal? number = Quantity;
            //      foreach (var item in morderListData)
            //      {
            //          //查询出工单已占用总数量
            //          var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();

            //          var Sumqty = mooccupies.Count > 0 ? mooccupies.Sum(x => x.moo_qty) : 0.00m;
            //          //判断此工单剩下数量是否还有
            //          if (item.morder_production_number - item.inventory_number - Sumqty > 0)
            //          {
            //              var Sum = item.morder_production_number - item.inventory_number - Sumqty;
            //              //需要数量-（计划数量-入库数量-已占用量）
            //              Quantity = Quantity - (item.morder_production_number - item.inventory_number - Sumqty);
            //              if (Quantity > 0)
            //              {
            //                  var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, Sum);
            //                  mes_Mooccupies.Add(mes_Mooccupy);
            //              }
            //              else
            //              {
            //                  break;
            //              }
            //          }

            //          //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;
            //      }
            //  }
            #endregion
            //TODO：返回占用数据，外层每个BOM根据占用工单数据判断是否满足。
            return mes_Mooccupies.OrderByDescending(s => s.moo_etime).ToList();
        }
        /// <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(mo_crm_seorderentry seorderentry, ic_item ic_item, mes_morder item, decimal? number)
        {
            //生成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 = number;
            mes_Mooccupy.moo_stime = item.moentry_sys_stime;
            mes_Mooccupy.moo_etime = item.moentry_sys_etime;
            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.org_id = seorderentry.org_id;
            return mes_Mooccupy;
        }
    }
}