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

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<List<mes_mooccupy>> 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:工单类型；
            //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
            && x.fitem_number == seorderentry.item_number);

            //首先满足需求数量工单其次判断是否满足交付日期、当数量不满足时继续查找最早交付日期订单 工单数量累加。
            //当前工单计划日期-1天 小于交付日期 && 计算生产数量-入库数据并且大于需求产品数量。
            var morderDataList = morderList.Where(x => x.moentry_sys_etime.Value.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.Value.AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();
            }
            //存在此数据满足当前BOM交付找到最早日期工单，则返回无需后续继续检查。
            foreach (var item in morderDataList)
            {
                //查询当前工单是否存在占用情况
                var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();
                if (mooccupies.Count > 0)
                {
                    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);
                        //当剩余需要数量大于0则继续寻找可占用工单，已满足需要数量停止循环查找
                        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);
            #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;
        }
        /// <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, 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;
        }
    }
}