DEMOMySql/MicroServices/Business/Business.Application/Quartz/ProductionScheduleAppService.cs

using Business.Business.Dto;
using Business.Core.Utilities;
using Business.Dto;
using Business.ResourceExamineManagement.Dto;
using Bussiness.EntityFrameworkCore.SqlRepositories;
using Bussiness.Model.MES.IC;
using Bussiness.Model.Production;
using Bussiness.Model.SRM;
using MongoDB.Driver;
using MongoDB.Driver.Linq;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Validation.Localization;

namespace Business.Quartz
{
    /// <summary>
    /// 生产排产服务
    /// </summary>
    public class ProductionScheduleAppService : ApplicationService
    {
        #region 服务
        /// <summary>
        /// 物料
        /// </summary>
        private ISqlRepository<ItemMaster> _itemMaster;

        /// <summary>
        /// 工单
        /// </summary>
        private ISqlRepository<WorkOrdMaster> _workOrdMaster;

        /// <summary>
        /// 工单物料明细
        /// </summary>
        private ISqlRepository<WorkOrdDetail> _workOrdDetail;

        /// <summary>
        /// 工单工艺路线明细
        /// </summary>
        private ISqlRepository<WorkOrdRouting> _workOrdRouting;

        /// <summary>
        /// 库存主数据
        /// </summary>
        private ISqlRepository<InvMaster> _invMaster;

        /// <summary>
        /// 生产线明细
        /// </summary>
        private ISqlRepository<ProdLineDetail> _prodLineDetail;

        /// <summary>
        /// 生产周期明细
        /// </summary>
        private ISqlRepository<PeriodSequenceDet> _periodSequenceDet;

        /// <summary>
        /// 排产结果明细
        /// </summary>
        private ISqlRepository<ScheduleResultOpMaster> _scheduleResultOpMaster;

        /// <summary>
        /// 工作日历数据
        /// </summary>
        private ISqlRepository<ShopCalendarWorkCtr> _shopCalendarWorkCtr;

        /// <summary>
        /// 排产异常记录表
        /// </summary>
        private ISqlRepository<ScheduleExceptionMaster> _scheduleExceptionMaster;

        /// <summary>
        /// 产线休息时间记录表
        /// </summary>
        private ISqlRepository<QualityLineWorkDetail> _qualityLineWorkDetail;

        /// <summary>
        /// 节假日记录表
        /// </summary>
        private ISqlRepository<HolidayMaster> _holidayMaster;

        /// <summary>
        /// 雪花算法
        /// </summary>
        SnowFlake help = new SnowFlake();

        /// <summary>
        /// 工作日历数据
        /// </summary>
        private List<ShopCalendarWorkCtr> calendars;

        /// <summary>
        /// 产线休息记录数据
        /// </summary>
        private List<QualityLineWorkDetail> qualityLines;

        /// <summary>
        /// 节假日记录数据
        /// </summary>
        private List<HolidayMaster> holidays;

        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public ProductionScheduleAppService(
            ISqlRepository<ItemMaster> itemMaster,
            ISqlRepository<WorkOrdMaster> workOrdMaster,
            ISqlRepository<WorkOrdDetail> workOrdDetail,
            ISqlRepository<WorkOrdRouting> workOrdRouting,
            ISqlRepository<ProdLineDetail> prodLineDetail,
            ISqlRepository<PeriodSequenceDet> periodSequenceDet,
            ISqlRepository<ScheduleResultOpMaster> scheduleResultOpMaster,
            ISqlRepository<InvMaster> invMaster,
            ISqlRepository<ShopCalendarWorkCtr> shopCalendarWorkCtr,
            ISqlRepository<ScheduleExceptionMaster> scheduleExceptionMaster,
            ISqlRepository<QualityLineWorkDetail> qualityLineWorkDetail,
            ISqlRepository<HolidayMaster> holidayMaster
            )
        { 
            _itemMaster= itemMaster;
            _workOrdMaster= workOrdMaster;
            _workOrdDetail= workOrdDetail;
            _workOrdRouting= workOrdRouting;
            _prodLineDetail = prodLineDetail;
            _periodSequenceDet = periodSequenceDet;
            _scheduleResultOpMaster= scheduleResultOpMaster;
            _invMaster= invMaster;
            _shopCalendarWorkCtr= shopCalendarWorkCtr;
            _scheduleExceptionMaster= scheduleExceptionMaster;
            _qualityLineWorkDetail= qualityLineWorkDetail;
            _holidayMaster = holidayMaster;
        }
        #endregion

        /// <summary>
        /// 执行生产排产
        /// </summary>
        public async void DoExt()
        {
            await DoProductShcedule();
        }

        /// <summary>
        /// 生产排产
        /// </summary>
        public async Task DoProductShcedule()
        {
            //1、获取需要排产的工单:Status为空且IsActive==1
            List<WorkOrdMaster> workOrds = _workOrdMaster.Select(p => string.IsNullOrEmpty(p.Status) && p.IsActive == 1).Result;
            if (workOrds.Count == 0)
            {
                return;
            }
            //获取排产工单的最早计划开工日期
            DateTime earlist = workOrds.Min(p => p.OrdDate.GetValueOrDefault()).Date;
            //2、获取数据
            //获取工单工艺路径数据
            List<WorkOrdRouting> workOrdRoutings = _workOrdRouting.Select(p => workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd) && p.Domain == "1001" && p.Status != "C" && p.IsActive == 1).Result;
            //获取物料对应的生产线信息:物料、工序对应的生产线
            List<ProdLineDetail> prodLines = _prodLineDetail.Select(p => workOrds.Select(m => m.ItemNum).Contains(p.Part) && p.Domain == "1001" && p.IsActive == 1).Result;
            //获取生产周期数据
            List<PeriodSequenceDet> periodSequences = _periodSequenceDet.Select(p=> workOrds.Select(m => m.ItemNum).Contains(p.ItemNum) && p.PlanDate >= earlist && p.Domain == "1001" && p.IsActive == 1).Result;
            //获取当前日期往后的排产记录数据
            List<ScheduleResultOpMaster> schedules = _scheduleResultOpMaster.Select(p => workOrds.Select(m => m.ItemNum).Contains(p.ItemNum) && p.WorkDate >= earlist && p.Domain == "1001").Result;
            //获取工作日历数据
            calendars = _shopCalendarWorkCtr.Select(p=>p.Domain == "1001" && p.IsActive == 1).Result;
            //获取产线休息记录数据
            qualityLines = _qualityLineWorkDetail.Select(p => p.Domain == "1001" && p.IsActive == 1).Result;
            //获取节假日记录数据
            holidays = _holidayMaster.Select(p => p.Domain == "1001" && p.IsActive == 1 && p.Dated >= earlist).Result;

            //3、排产
            //排产异常记录
            List<ScheduleExceptionMaster> scheduleExceptions = new List<ScheduleExceptionMaster>();
            //生产周期
            List<PeriodSequenceDet> periodsDet = new List<PeriodSequenceDet>();
            //排产记录表
            List<ScheduleResultOpMaster> scheduleResults = new List<ScheduleResultOpMaster>();
            foreach (var item in workOrds)
            {
                DateTime planStart = item.OrdDate.GetValueOrDefault().Date;
                //工序预处理
                List<WorkOrdRoutingDto> routingDtos = ProcPretreatment(workOrdRoutings, prodLines);
                
                //获取主工序对应的产线
                var first = routingDtos.Where(p => p.level == 1).FirstOrDefault();
                if (first == null)
                {
                    //记录排产异常原因
                    scheduleExceptions.Add(new ScheduleExceptionMaster
                    {
                        RecID = help.NextId(),
                        Domain = "1001",
                        WorkOrd = item.WorkOrd,
                        Remark = "工单没有维护工序数据",
                        CreatTime = DateTime.Now.Date
                    }); 
                    continue;
                }
                if (first.lines.Count() == 0)
                {
                    //记录排产异常原因
                    scheduleExceptions.Add(new ScheduleExceptionMaster
                    {
                        RecID = help.NextId(),
                        Domain = "1001",
                        WorkOrd = item.WorkOrd,
                        Remark = "工单没有维护产线数据",
                        CreatTime = DateTime.Now.Date
                    });
                    continue;
                }
                //确定主工序排产产线以及排产开始时间
                LineDto line = ConfirmLine(first.Op, planStart, first.lines, schedules);
                //产线排产
                LineSchedule(item, line, routingDtos, periodsDet, scheduleResults, scheduleExceptions);
            }
        }

        /// <summary>
        /// 排产
        /// </summary>
        /// <param name="workOrd">工单</param>
        /// <param name="line">主工序对应的产线</param>
        /// <param name="routingDtos">每层级工序对应的产线信息</param>
        /// <param name="periodsDet">生产周期</param>
        /// <param name="scheduleResults">排产结果</param>
        /// <param name="scheduleExceptions">排产异常记录</param>
        public void LineSchedule(WorkOrdMaster workOrd, LineDto line, List<WorkOrdRoutingDto> routingDtos,List<PeriodSequenceDet> periodsDet, List<ScheduleResultOpMaster> scheduleResults, List<ScheduleExceptionMaster> scheduleExceptions)
        {
            //生产周期
            List<PeriodSequenceDet> curSequences = new List<PeriodSequenceDet>();
            //排产明细
            List< ScheduleResultOpMaster > curScheduleRsts = new List<ScheduleResultOpMaster >();
            //获取当前产线的工作日历
            var curCalendars = calendars.Where(p => p.ProdLine == line.Line).ToList();
            //获取当前产线的休息记录
            var curQtyDtls = qualityLines.Where(p => p.ProdLine == line.Line).OrderBy(m => m.Line).ToList();
            if (curCalendars.Count() == 0 || curCalendars.Select(p=>p.WeekDay).Distinct().Count() != 7)
            {
                //记录排产异常原因
                scheduleExceptions.Add(new ScheduleExceptionMaster
                {
                    RecID = help.NextId(),
                    Domain = "1001",
                    WorkOrd = workOrd.WorkOrd,
                    Remark = "工单对应产线工作日历数据错误",
                    CreatTime = DateTime.Now.Date
                });
                return;
            }
            //产线可排产开始日期
            DateTime workStartTime = DealStartTime(line.StartTime, curCalendars, curQtyDtls);

        }
        
        /// <summary>
        /// 计算主产线实际排产开始时间
        /// </summary>
        /// <param name="startTime">开始时间</param>
        /// <param name="curCalendars">当前产线工作日历</param>
        /// <param name="curQtyDtls">当前产线休息记录</param>
        /// <returns></returns>
        public DateTime DealStartTime(DateTime startTime,List<ShopCalendarWorkCtr> curCalendars, List<QualityLineWorkDetail> curQtyDtls)
        { 
            //实际排产开始时间
            DateTime actStart = startTime;
            //开始时间是周几
            int weekDay = (int)startTime.DayOfWeek;
            //当天的工作日历
            var shopCal = curCalendars.Where(p => p.WeekDay == weekDay).First();
            //当前日期的工作时间段
            List<LineWorkPointDto> workPoints = DealWorkDayToLevels(startTime, shopCal,curQtyDtls);
            //计算starttime处于那个工作时间段
            var curPoint = workPoints.Where(p => startTime >= p.StartPoint && startTime <= p.EndPoint).FirstOrDefault();
            if (startTime != curPoint.EndPoint)
            {
                return startTime;
            }
            //查询下一时间段的开始时间点
            var nextPoint = workPoints.Where(p => p.Level == curPoint.Level + 1).FirstOrDefault();
            if (nextPoint != null)
            {
                return nextPoint.StartPoint;
            }
            //开始时间为今天下班时间，实际排产开始时间为下一个工作日的开始时间
            actStart = GetNextWorkDay(weekDay, startTime, curCalendars);
            return actStart;
        }

        /// <summary>
        /// 获取下一个工作日开始时间
        /// </summary>
        /// <param name="weekDay">当前周几</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="curCalendars">当前产线的工作日历</param>
        /// <returns></returns>
        public DateTime GetNextWorkDay(int weekDay, DateTime startTime, List<ShopCalendarWorkCtr> curCalendars)
        {
            DateTime rtnData = startTime;
            //下一天
            DateTime nextDate = startTime.Date.AddDays(1);
            //下一天是周几
            int nextWeekDay = (weekDay + 1) % 7;
            var calendar = curCalendars.FirstOrDefault(p=>p.WeekDay == nextWeekDay);
            //判断下一天是否是工作日
            if (nextWeekDay == 0 || nextWeekDay == 6)//下一天是周六或者周日，需要判断是否调休，需要加班
            {
                if (!holidays.Exists(p => p.Dated.GetValueOrDefault().Date == nextDate && p.Ufld1 == "调休"))//下一天是周末
                {
                    //递归继续找下一个工作日
                    GetNextWorkDay(nextWeekDay, nextDate, curCalendars);
                }
                rtnData = nextDate.AddHours((double)calendar.ShiftsStart1);
                return rtnData;
            }
            //下一天不是周六周日，需要判断是不是节假日
            if (holidays.Exists(p => p.Dated.GetValueOrDefault().Date == nextDate && p.Ufld1 == "休假"))//是节假日
            {
                //递归继续找下一个工作日
                GetNextWorkDay(nextWeekDay, nextDate, curCalendars);
            }
            rtnData = nextDate.AddHours((double)calendar.ShiftsStart1);
            return rtnData;
        }

        /// <summary>
        /// 处理当前日期的工作时间段
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="shopCal">当前产线的工作日历-周几</param>
        /// <param name="curQtyDtls">每天休息记录</param>
        /// <returns></returns>
        public List<LineWorkPointDto> DealWorkDayToLevels(DateTime startTime, ShopCalendarWorkCtr shopCal, List<QualityLineWorkDetail> curQtyDtls)
        {
            //年-月-日
            string date = startTime.Date.ToString("yyyy-MM-dd");
            //排产记录结束日期是周几
            int weekDay = (int)startTime.DayOfWeek;
            //计算当天的开工时间点，停工时间点
            DateTime dayStartPoint = startTime.Date.AddHours(Convert.ToDouble(shopCal.ShiftsStart1));
            DateTime dayEndPoint = dayStartPoint.AddHours(Convert.ToDouble(shopCal.ShiftsHours1));
            //工作时间段
            List<LineWorkPointDto> workPoints = new List<LineWorkPointDto>();
            LineWorkPointDto dto = new LineWorkPointDto();
            dto.Level = 1;
            dto.Line = shopCal.ProdLine;
            dto.WeekDay = weekDay;
            dto.StartPoint = dayStartPoint;
            int level = 1;
            foreach (var item in curQtyDtls)
            {
                DateTime endPoint = Convert.ToDateTime(date + " " + item.RestTimePoint);
                workPoints.Add(dto);
                level++;
                dto = new LineWorkPointDto();
                dto.Level = level;
                dto.Line = shopCal.ProdLine;
                dto.WeekDay = weekDay;
                dto.StartPoint = endPoint.AddMinutes(item.RestTime);
            }
            dto.EndPoint = dayEndPoint;
            workPoints.Add(dto);

            return workPoints;
        }

        /// <summary>
        /// 确定工序排产对应的产线
        /// </summary>
        /// <param name="op">主产线的最后一道工序</param>
        /// <param name="planStart">当前工单计划开始时间</param>
        /// <param name="lines">主工序对应的产线</param>
        /// <param name="scheduleResults"></param>
        /// <returns></returns>
        public LineDto ConfirmLine(int op, DateTime planStart, List<LineDto> lines, List<ScheduleResultOpMaster> scheduleResults)
        {
            LineDto rtn = new LineDto();
            //多条产线确认最优产线：按开工时间升序，产能倒叙排序
            foreach (var item in lines)
            {
                //获取当前产线的排产最晚结束时间
                var schedule = scheduleResults.Where(p => p.Line == item.Line && p.Op == op).OrderByDescending(p => p.WorkEndTime).FirstOrDefault();
                //当前产线没有排产记录，开始日期= planStart;
                //当前产线有排产记录，如果产线排产最晚结束时间≤planStart 开始日期=planStart,反之 开始日期 = WorkEndTime
                var latest = schedule == null ? planStart : (schedule.WorkEndTime <= planStart ? planStart : schedule.WorkEndTime);
                if (rtn == null)
                {
                    rtn.Line = item.Line;
                    rtn.Rate = item.Rate;
                    rtn.StartTime = latest;
                }
                if (latest < rtn.StartTime || (latest == rtn.StartTime && item.Rate > rtn.Rate))
                {//当前产线最早开工时间早于之前的产线或者产线开工时间相同且当前产线产能大于之前的产线，则当前产线为优先选择产线
                    rtn.Line = item.Line;
                    rtn.Rate = item.Rate;
                    rtn.StartTime = latest;
                }
            }
            return rtn;
        }

        /// <summary>
        /// 工单工艺路线预处理
        /// </summary>
        /// <param name="woRuntings">工单工序</param>
        /// <param name="prodLines">产线</param>
        /// <returns></returns>
        public List<WorkOrdRoutingDto> ProcPretreatment(List<WorkOrdRouting> woRuntings, List<ProdLineDetail> prodLines)
        {
            List<WorkOrdRoutingDto> routingDtos = new List<WorkOrdRoutingDto>();
            //取主工序(第一层级工序)
            var firsts = woRuntings.Where(p =>p.ParentOp == 0).ToList();
            if (firsts.Count == 0)
            {
                return routingDtos;
            }
            WorkOrdRoutingDto dto = new WorkOrdRoutingDto();
            //当前层级的关键工序/报工工序(当前层级工序Op最大的工序)
            var lastOp = firsts.OrderByDescending(p => p.OP).FirstOrDefault();
            if (lastOp != null) {
                dto.ParentOp = lastOp.ParentOp;
                dto.level = 1;
                dto.Op = lastOp.OP;
                //当前层级工序对应的产线
                var curLines = prodLines.Where(p => p.Part == lastOp.WorkOrd && p.Op == lastOp.OP).Select(m => new LineDto
                {
                    Line = m.Line,
                    Rate = m.Rate,
                    SetupTime = m.SetupTime
                }).AsQueryable<LineDto>().ToList();
                dto.lines = curLines;
                routingDtos.Add(dto);
            }
            
            //递归处理其他层级工序
            RecursionProc(woRuntings, firsts, 1, routingDtos, prodLines);

            return routingDtos;
        }

        /// <summary>
        /// 递归处理工序
        /// </summary>
        /// <param name="woRuntings">工单工序</param>
        /// <param name="preLevels">上-层级工序</param>
        /// <param name="level">层级</param>
        /// <param name="routingDtos">返回结果</param>
        /// <param name="prodLines">产线</param>
        public void RecursionProc(List<WorkOrdRouting> woRuntings, List<WorkOrdRouting> preLevels, int level, List<WorkOrdRoutingDto> routingDtos, List<ProdLineDetail> prodLines)
        {
            //获取当前层级工序
            var curLevels = woRuntings.Where(p => preLevels.Select(m=>m.OP).Contains(p.ParentOp)).ToList();
            if (curLevels.Count() == 0)
            {
                return;
            }
            //获取父级Op
            var parentOps = curLevels.Select(m => m.ParentOp).Distinct().ToList();
            foreach (var item in parentOps)
            {
                var dto = new WorkOrdRoutingDto();
                var lastOp = curLevels.Where(p=>p.ParentOp == item).OrderByDescending(m=>m.OP).FirstOrDefault();
                if (lastOp != null){
                    dto.Op = lastOp.OP;
                    dto.ParentOp = lastOp.ParentOp;
                    dto.level = level + 1;
                    //当前层级工序对应的产线
                    var curLines = prodLines.Where(p => p.Part == lastOp.WorkOrd && p.Op == lastOp.OP).Select(m => new LineDto
                    {
                        Line = m.Line,
                        Rate = m.Rate,
                        SetupTime = m.SetupTime
                    }).AsQueryable<LineDto>().ToList();
                    dto.lines = curLines;
                    routingDtos.Add(dto);
                }
            }
            //递归
            RecursionProc(woRuntings, curLevels, level + 1, routingDtos,prodLines);
        }
    }
}