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

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Domain.Repositories;
using Business.Models;
using Microsoft.AspNetCore.Authorization;
using Business.Permissions;
using XCZ;
using Business.ResourceExamineManagement.Dto;
using Bussiness.Model.MES.IC;
using AutoMapper.Internal.Mappers;
using Bussiness.Model.Tech;
using Bussiness.Model.Production;
using Business.Core.MongoDBHelper;
using Business.Core.Utilities;
using Hangfire.Storage.Monitoring;
using Business.BookManagement.Dto;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Application.Services;
using ZstdSharp.Unsafe;
using System.Transactions;
using NUglify.JavaScript.Syntax;
using System.Linq.Expressions;
using Volo.Abp.Validation.StringValues;
using System.Runtime.CompilerServices;

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

        /// <summary>
        /// 物料详情
        /// </summary>
        private readonly IMongoDB<ic_item> _ic_item;
        //private IRepository<ic_item, long> _mysql_ic_item;
        /// <summary>
        /// 物料BOM
        /// </summary>
        private readonly IMongoDB<ic_bom> _ic_bom;
        //private IRepository<ic_bom, long> _mysql_ic_bom;
        /// <summary>
        /// 物料BOM明细
        /// </summary>
        private readonly IMongoDB<ic_bom_child> _ic_bom_child;
        //private IRepository<ic_bom_child, long> _mysql_ic_bom_child;
        /// <summary>
        /// 生产工单主表
        /// </summary>
        private readonly IMongoDB<mes_morder> _mes_morder;

        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="icitem"></param>
        /// <param name="icbom"></param>
        public ResourceExamineAppService(
            IMongoDB<mes_technique> mes_technique,
            IMongoDB<ic_item> ic_item,
            IMongoDB<ic_bom> ic_bom,
            IMongoDB<ic_bom_child> ic_bom_child,
            IMongoDB<mes_morder> mes_morder
            //IRepository<ic_item, long> mysql_ic_item,
            //IRepository<ic_bom, long> mysql_ic_bom,
            //IRepository<ic_bom_child, long> mysql_ic_bom_child,

            )
        {
            _mes_technique = mes_technique;
            _ic_item = ic_item;
            _ic_bom = ic_bom;
            _ic_bom_child = ic_bom_child;
            _mes_morder = mes_morder;
            //_mysql_ic_item = mysql_ic_item;
            //_mysql_ic_bom = mysql_ic_bom;
            //_mysql_ic_bom_child = mysql_ic_bom_child;
        }

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

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

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

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

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

        /// <summary>
        /// 资源检查
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<PschedDto> ReceiveResult(SeorderentryDto input)
        {
            //测试代码
            await test();
            
            return null;
            throw new NotImplementedException();

        }



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

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

            //1.3、获取当前工艺路径下的工序数据
            List<mes_process> process = _mes_process.GetManyByCondition(p => p.Id.IsIn(tech_Processes.Select(m => m.proc_id))).Result;

            //1.3、获取工艺工序关联工位信息
            List<mes_tech_proc_workshop> tech_Proc_Workshops = _mes_tech_proc_workshop.GetManyByCondition(x => x.tech_proc_id.IsIn<long>(tech_Processes.Select(m => m.Id))).Result;

            //1.4、获取工位占用情况
            //List<mes_schedule_occupy> schedule_Occupies = _mes_schedule_occupy.GetManyByCondition().Result;
            #endregion

            #region 计算产能，得到耗时
            /*产能计算有两种模式:1-UPH;2-节拍时间
             *1、根据工艺路径设置的效率计算层级，来获取参与产能计算的所有工序/子工序
             *2、根据当前工序设置的计算模式UPH/节拍时间来计算当前工序生产所需时间T1
             *3、当前工序生产所需时间T1*效率系数Rate得到实际的生产所需时间T2(流水线不需要*效率系数)
             *4、当前工序实际生产所需时间T2+当前工序前置准备时间得到当前工序生产所需总时间
             *5、所有工序生产总时间加起来得到生产所需总时间
            */
            //1、获取参与计算的所有工序/子工序
            var tech_pro_list = tech_Processes.Where(p => p.level == tech.level).ToList();
            //生产总时间(分钟)
            decimal sumTimes = 0.00m;
            //记录按照CT参与计算的工序的父级Id
            List<long> exists = new List<long>();
            foreach (var item in tech_pro_list)
            {
                //数据校验
                //获取当前工序
                var curProcess = process.FirstOrDefault(p => p.Id == item.proc_id);
                if (item.type == 1 && item.ct == 0)
                {
                    throw new NotImplementedException(string.Format("工艺[{0}]下的工序[{1}]节拍时间设置有误，请调整！",tech.tech_name, curProcess.proc_name));
                }
                if (item.type == 2 && item.uph == 0)
                {
                    throw new NotImplementedException(string.Format("工艺[{0}]下的工序[{1}]UPH设置有误，请调整！", tech.tech_name, curProcess.proc_name));
                }

                if (item.parentprocid != null)//存在父子级关系
                {
                    //判断当前父级是否已经参与过计算
                    if (exists.Contains(item.parentprocid.Value))
                    {
                        continue;
                    }
                    //记录父级id
                    exists.Add(item.parentprocid.Value);
                    //获取同一父级下的子工序
                    var childs = tech_Processes.Where(p => p.parentprocid == item.parentprocid).ToList();
                    decimal maxTime = 0.00m;//记录同一父级下最大耗时
                    decimal time = 0.00m;
                    //2、两种计算模式UPH/节拍时间
                    if (item.type == 2)//UPH(每小时生产个数),取同一父级下最长耗时
                    {
                        foreach (var chd in childs)
                        {
                            //当前工序消耗时间
                            time = quantity / item.uph.Value * 60 * item.effect_ratio.Value;
                            if (time > maxTime)
                            {
                                maxTime = time;
                            }
                        }
                        sumTimes += maxTime;
                        continue;
                    }
                    //3、根据节拍时间计算
                    //sum(CT)
                    decimal sumCT = childs.Sum(p => p.ct.Value);
                    //max(CT)
                    decimal maxCT = childs.OrderByDescending(p => p.ct).FirstOrDefault().ct.Value;
                    //sum(LT)
                    decimal sumLT = childs.Sum(p => p.readytime.Value);
                    //当前流水线消耗时间
                    sumTimes += (packages - 1) * maxCT + sumCT + sumLT;
                }
                else{//不存在父子级关系
                    //2、两种计算模式UPH/节拍时间
                    if (item.type == 2)//uph
                    {
                        //当前工序消耗时间
                        sumTimes += quantity / item.uph.Value * 60 * item.effect_ratio.Value + item.readytime.Value;
                        //计算完成，进行下一次循环
                        continue;
                    }
                    //节拍时间：流水线，从流水线起始工序开始计算
                    if (item.preprocid != null)
                    {
                        //上-工序Id不为null，说明不是流水线起始工序，进行下一次循环
                        continue;
                    }
                    List<mes_tech_process> allProcess = new List<mes_tech_process>();
                    //递归，获取起始工序的后续工序
                    GetNextProcess(tech_Processes, item, allProcess);
                    //sum(CT)
                    decimal sumCT = allProcess.Sum(p => p.ct.Value);
                    //max(CT)
                    decimal maxCT = allProcess.OrderByDescending(p => p.ct).FirstOrDefault().ct.Value;
                    //sum(LT)
                    decimal sumLT = allProcess.Sum(p => p.readytime.Value);
                    //当前流水线消耗时间
                    sumTimes += (packages - 1) * maxCT + sumCT + sumLT;
                }
            }
            #endregion

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

        /// <summary>
        /// 递归获取工序
        /// </summary>
        /// <param name="tech_Processes"></param>
        /// <param name="item"></param>
        /// <returns></returns>
        private void GetNextProcess(List<mes_tech_process> tech_Processes, mes_tech_process item, List<mes_tech_process> allProcess)
        {
            allProcess.Add(item);
            //判断下一工序id是否为null
            if (item.nextprocid != null)
            {
                var nextProc = tech_Processes.FirstOrDefault(p => p.proc_id == item.nextprocid);
                GetNextProcess(tech_Processes, nextProc, allProcess);
            }
        }





        /// <summary>
        /// 检查在制工单
        /// </summary>
        /// <param name="bomNumber">Bom编码</param>
        /// <param name="Quantity">需要数量</param>
        /// <returns></returns>
        public async Task CheckMorder(string bomNumber, decimal? Quantity, DateTime EndDate)
        {
            if (string.IsNullOrEmpty(bomNumber) || Quantity < 0)
            {
                //TODO：入参异常；
                //throw new NotImplementedException();
            }
            var morderList = _mes_morder.GetAll().Result;
            var morderTypeList = morderList.Where(x => x.work_order_type == "备库工单" && x.morder_type == "计划工单" && x.bom_number == bomNumber && (x.morder_state == "初始" || x.morder_state == "下达")).ToList();

            //查询生产工单类型为计划工单并且工单类型为备库工单 并且BOM编码一致数据
            // 订单状态为 初始或下达工单
            var SatisfyQuantityList = morderTypeList.Where(x => x.morder_production_number >= Quantity).
                ToList().OrderBy(x => x.moentry_sys_etime).FirstOrDefault();
            if (SatisfyQuantityList == null)
            {

            }
            else
            {

            }
            // List =>数量满足Quantity && 生成工单结束日期最早
        }

        public void BomPretreatment(long? orderid, long? BomId, int Quantity)
        {
            if (orderid == null)
            {
                //throw new bu
            }
            if (BomId == null)
            {
                //throw new bu
            }

            //var query = (await _ic_bom.GetQueryableAsync()).WhereIf(true, a => a.bom_id == BomId).ToList();
            var help = new SnowFlake();
            var bomlist = _ic_bom.GetAll().Result;
            var bomchildlist = _ic_bom_child.GetAll().Result;
            var icitemlist = _ic_item.GetAll().Result;
            List<BomChildExamineDto> returnlist = new List<BomChildExamineDto>();
            var dto = new BomChildExamineDto();
            dto.bom_id = BomId.Value;
            dto.level = 1;
            dto.id = help.NextId();
            dto.parent_id = help.NextId();
            dto.qty = 1;
            dto.num = "1";
            dto.isbom = 1;
            GetBomList(bomlist, bomchildlist, icitemlist, dto, returnlist);
        }


        public void GetBomList(List<ic_bom> bomlist, List<ic_bom_child> bomchildlist, List<ic_item> icitemlist, BomChildExamineDto dto, List<BomChildExamineDto> returnlist)
        {
            int level = dto.level++;//初始化定义level层级
            var help = new SnowFlake();

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

            }
            //var dto = new BomChildExamineDto();
            //dto.level = level;
            //dto.bom_id = bomId;
            //dto.id = help.NextId();
            //dto.parent_id = parent_id;
            dto.item_id = bom.icitem_id;
            dto.item_name = bom.item_name;
            dto.item_code = bom.item_number;
            dto.model = item.model;
            dto.unit = bom.unit;
            dto.erp_cls = item.erp_cls;
            dto.erp_cls_name = item.erp_cls_name;

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

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

        }


        public void BomSubstitute(List<BomChildExamineDto> returnlist)
        {
            returnlist = returnlist.OrderBy(s => s.num).ToList();
            
            List<long> idlist = new List<long>();
            foreach (var item in returnlist)
            {
                if (item.num != "1")
                {
                    
                }
            }
        }
    }
}