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

using Business.Business.Dto;
using Business.Core.Utilities;
using Business.Domain;
using Business.Dto;
using Business.EntityFrameworkCore.SqlRepositories;
using Business.ResourceExamineManagement.Dto;
using Business.StructuredDB.Production;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Configuration;
using System.Linq;
using System.Threading.Tasks;
using System.Transactions;
using Volo.Abp.Application.Services;
using Volo.Abp.MultiTenancy;
using Microsoft.Extensions.Configuration;
using MongoDB.Driver.Linq;
using Amazon.Runtime.Internal.Util;
using IdentityModel.Client;
using Amazon.Runtime;
using Magicodes.ExporterAndImporter.Core.Extension;
using Volo.Abp.Domain.Repositories;
using System.Runtime.CompilerServices;
using NUglify.JavaScript;
using MathNet.Numerics.Optimization.LineSearch;
using MathNet.Numerics;
using Volo.Abp.Options;

namespace Business.ResourceExamineManagement
{
    /// <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<PurOrdMaster> _purOrdMaster;
        private ISqlRepository<PurOrdDetail> _purOrdDetail;

        /// <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<QualityLineWorkDetail> _qualityLineWorkDetail;

        /// <summary>
        /// 产线人员配置表
        /// </summary>
        private ISqlRepository<ProdLineDetailRunCrew> _prodLineDetailRunCrew;

        /// <summary>
        /// 加班设置表
        /// </summary>
        private ISqlRepository<ResourceOccupancyTime> _resourceOccupancyTime;

        /// <summary>
        /// 加班设置表
        /// </summary>
        private ISqlRepository<GeneralizedCodeMaster> _generalizedCodeMaster;

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

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

        /// <summary>
        /// 排产结果明细
        /// </summary>
        private ISqlRepository<ProductScheduleControl> _productScheduleControl;

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

        private readonly ICurrentTenant _currentTenant;

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

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

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

        /// <summary>
        /// 生产线UPH设置
        /// </summary>
        private List<ProdLineDetailRunCrew> prodLineDetailRunCrews;

        /// <summary>
        /// 加班设置
        /// </summary>
        private List<ResourceOccupancyTime> resourceOccupancyTimes;

        /// <summary>
        /// 领料单
        /// </summary>
        private ISqlRepository<NbrMaster> _nbrMaster;

        /// <summary>
        /// 领料单明细
        /// </summary>
        private ISqlRepository<NbrDetail> _nbrDetail;

        /// <summary>
        /// 工单工序开始准备时间记录
        /// </summary>
        private ISqlRepository<WorkOrdSetupTimeRecord> _workOrdSetupTimeRecord;

        /// <summary>
        /// 工单工序开始准备时间记录
        /// </summary>
        private List<WorkOrdSetupTimeRecord> timeRecords;

        /// <summary>
        /// 新增工序准备开始时间记录
        /// </summary>
        private List<WorkOrdSetupTimeRecord> inserts = new List<WorkOrdSetupTimeRecord>();

        /// <summary>
        /// 更新工序准备开始时间记录
        /// </summary>
        private List<WorkOrdSetupTimeRecord> updates = new List<WorkOrdSetupTimeRecord>();

        /// <summary>
        /// 生产工单主表
        /// </summary>
        private readonly IRepository<mes_morder, long> _mysql_mes_morder;

        /// <summary>
        /// 工厂id
        /// </summary>
        private string domain = "";

        /// <summary>
        /// 排产任务执行时间
        /// </summary>
        private DateTime scheTime;

        /// <summary>
        /// 可用设备数
        /// </summary>
        private readonly GetAvailableEquipmentAppService _getAvailableEquipmentAppService;
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public ProductionScheduleAppService(
            ISqlRepository<ItemMaster> itemMaster,
            ISqlRepository<WorkOrdMaster> workOrdMaster,
            ISqlRepository<WorkOrdDetail> workOrdDetail,
            ISqlRepository<WorkOrdRouting> workOrdRouting,
            ISqlRepository<ProdLineDetail> prodLineDetail,
            ISqlRepository<ProdLineDetailRunCrew> prodLineDetailRunCrew,
            ISqlRepository<ResourceOccupancyTime> resourceOccupancyTime,
            ISqlRepository<PeriodSequenceDet> periodSequenceDet,
            ISqlRepository<ScheduleResultOpMaster> scheduleResultOpMaster,
            ISqlRepository<InvMaster> invMaster,
            ISqlRepository<ShopCalendarWorkCtr> shopCalendarWorkCtr,
            ISqlRepository<QualityLineWorkDetail> qualityLineWorkDetail,
            ISqlRepository<HolidayMaster> holidayMaster,
            ISqlRepository<GeneralizedCodeMaster> generalizedCodeMaster,
            ICurrentTenant currentTenant,
            ISqlRepository<ScheduleExceptionMaster> scheduleExceptionMaster,
            ISqlRepository<NbrMaster> nbrMaster,
            IRepository<mes_morder, long> mysql_mes_morder,
            ISqlRepository<WorkOrdSetupTimeRecord> workOrdSetupTimeRecord,
            ISqlRepository<ProductScheduleControl> productScheduleControl,
            ISqlRepository<PurOrdMaster> purOrdMaster,
            ISqlRepository<PurOrdDetail> purOrdDetail,
            ISqlRepository<NbrDetail> nbrDetail
            )
        {
            _itemMaster = itemMaster;
            _workOrdMaster = workOrdMaster;
            _workOrdDetail = workOrdDetail;
            _workOrdRouting = workOrdRouting;
            _nbrMaster = nbrMaster;
            _prodLineDetail = prodLineDetail;
            _prodLineDetailRunCrew = prodLineDetailRunCrew;
            _resourceOccupancyTime = resourceOccupancyTime;
            _periodSequenceDet = periodSequenceDet;
            _scheduleResultOpMaster = scheduleResultOpMaster;
            _invMaster = invMaster;
            _shopCalendarWorkCtr = shopCalendarWorkCtr;
            _qualityLineWorkDetail = qualityLineWorkDetail;
            _holidayMaster = holidayMaster;
            _generalizedCodeMaster = generalizedCodeMaster;
            _currentTenant = currentTenant;
            _scheduleExceptionMaster = scheduleExceptionMaster;
            _productScheduleControl = productScheduleControl;
            _mysql_mes_morder = mysql_mes_morder;
            _workOrdSetupTimeRecord = workOrdSetupTimeRecord;
            _nbrDetail = nbrDetail;
            _purOrdMaster = purOrdMaster;
            _purOrdDetail = purOrdDetail;
        }
        #endregion

        /// <summary>
        /// 生产排产-定时任务
        /// </summary>
        public async void DoExt()
        {
            //定时任务排产:获取工厂id
            IConfiguration configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json", optional: true, reloadOnChange: true).Build();
            domain = configuration.GetConnectionString("Factory_id");

            ////获取需要排产的工单(获取四周的工单:正常工单+已审批通过的特殊工单)
            //DateTime endDate = DateTime.Now.Date.AddDays(28).AddDays(1);
            //取数开始时间为当前时间
            DateTime startTime = DateTime.Now;
            scheTime = startTime;
            //尚未开始生产的工单+正在生产的工单(工单需求数量>已完成数量)
            var workOrds = _workOrdMaster.Select(p => p.IsActive && p.Domain == domain && (p.QtyOrded - p.QtyCompleted) > 0 && p.Status !="C" && p.Status != "c" && !string.IsNullOrEmpty(p.Status) && (string.IsNullOrEmpty(p.Typed) || (!string.IsNullOrEmpty(p.Typed) && p.Typed.ToUpper() != "PW" && p.BusinessID >0 ))).ToList();
            if (workOrds.Any())
            {
                await DoProductSchedule(startTime, workOrds, domain, 1);
            }
        }

        /// <summary>
        /// 生产排产
        /// </summary>
        /// <param name="startTime">排产开始时间</param>
        /// <param name="workOrds">需要重新排产的工单</param>
        /// <param name="factoryid">工单的工厂id</param>
        /// <param name="type">排产类型：1-自动排产；2-手动排产</param>
        /// <returns></returns>
        public async Task<string> DoProductSchedule(DateTime startTime,List<WorkOrdMaster> workOrds, string factoryid,int type, List<WorkPriorityDto> dbWorkOrds=null)
        {
            //记录工厂id
            domain = factoryid;
            //记录排产开始时间
            scheTime = startTime;
            if (dbWorkOrds == null)
            {
                //获取工单领料单
                var nbrMasterList = _nbrMaster.Select(x => x.Domain == domain && x.Type.ToUpper() == "SM" && workOrds.Select(s => s.WorkOrd).Contains(x.WorkOrd)).ToList();
                //获取领料单明细
                var nbrDtlLists = _nbrDetail.Select(x => x.Domain == domain && nbrMasterList.Select(s => s.Nbr).Contains(x.Nbr)).ToList();
                workOrds = workOrds.OrderBy(p => p.Priority).ToList();
                //记录工单数据
                dbWorkOrds = workOrds.Select(p => new WorkPriorityDto
                {
                    WorkOrd = p.WorkOrd,
                    Priority = p.Priority,
                    QtyOrded = p.QtyOrded
                }).ToList();
                #region 优先级

                ////处理工单优先级：正常投产工单优先级最高，其次是前处理状态为部分完成/全部完成,其他按照工单优先级排
                //decimal ytc = 1m;
                //decimal ktc = 10000m;
                //decimal bktc = 20000m;
                //for (int i = 0; i < workOrds.Count; i++)
                //{
                //    //正在投产
                //    if (!string.IsNullOrEmpty(workOrds[i].Status) && workOrds[i].Status.ToUpper() == "W")
                //    {
                //        workOrds[i].Priority = ytc;
                //        ytc++;
                //        continue;
                //    }
                //    //需要前处理的领料单
                //    var qclNbr = nbrMasterList.FirstOrDefault(p => p.WorkOrd == workOrds[i].WorkOrd && p.TransType == "PrevProcess");
                //    //不需要前处理的领料单
                //    var bqclNbr = nbrMasterList.FirstOrDefault(p => p.WorkOrd == workOrds[i].WorkOrd && p.TransType != "PrevProcess");
                //    List<NbrDetail> bqclNbrDtls = new List<NbrDetail>();
                //    if (bqclNbr != null)
                //    {
                //        bqclNbrDtls = nbrDtlLists.Where(p => p.Nbr == bqclNbr.Nbr).ToList();
                //    }
                //    //存在领料单：不需要前处理-领料单明细存在已关闭物料，需要前处理-状态为部分完成或者全部完成
                //    if (qclNbr != null && bqclNbr != null)
                //    {
                //        if ((qclNbr.PretreatmentState == "50" || qclNbr.PretreatmentState == "completed") && bqclNbrDtls.Exists(p => p.Status.ToUpper() == "C"))
                //        {
                //            workOrds[i].Priority = ktc;
                //            ktc++;
                //            continue;
                //        }
                //        workOrds[i].Priority = bktc;
                //        bktc++;
                //        continue;
                //    }
                //    if (qclNbr != null && bqclNbr == null)
                //    {
                //        if (qclNbr.PretreatmentState == "50" || qclNbr.PretreatmentState == "completed")
                //        {
                //            workOrds[i].Priority = ktc;
                //            ktc++;
                //            continue;
                //        }
                //        workOrds[i].Priority = bktc;
                //        bktc++;
                //        continue;
                //    }
                //    if (qclNbr == null && bqclNbr != null)
                //    {
                //        if (bqclNbrDtls.Exists(p => p.Status.ToUpper() == "C"))
                //        {
                //            workOrds[i].Priority = ktc;
                //            ktc++;
                //            continue;
                //        }
                //        workOrds[i].Priority = bktc;
                //        bktc++;
                //        continue;
                //    }
                //    if (qclNbr == null && bqclNbr == null)
                //    {
                //        workOrds[i].Priority = bktc;
                //        bktc++;
                //        continue;
                //    }
                //}
                #endregion
            }

            //2、获取数据
            //获取工单工艺路径数据
            List<WorkOrdRouting> workOrdRoutings = _workOrdRouting.Select(p => workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd) && p.ParentOp == 0 && p.Domain == domain && p.Status != "C" && p.IsActive);
            
            //获取物料对应的生产线信息:物料、工序对应的生产线
            List<ProdLineDetail> prodLines = _prodLineDetail.Select(p => workOrds.Select(m => m.ItemNum).Contains(p.Part) && p.Domain == domain && p.IsActive);
            List<string> lines = prodLines.Select(p => p.Line).ToList();
            //获取非标准产线人员配置
            prodLineDetailRunCrews = _prodLineDetailRunCrew.Select(x => prodLines.Select(p => p.RecID).Contains(x.ProdLineDetailRecID) && x.IsActive && x.Domain == domain).ToList();
            //获取加班设置
            resourceOccupancyTimes = _resourceOccupancyTime.Select(x => prodLines.Select(p => p.Line).Contains(x.Resource) && x.IsActive && x.Domain == domain && x.StartTime.Value > DateTime.Now).ToList();
            //获取当前日期往后的排产记录数据
            List<ItemMaster> itemMasters = _itemMaster.Select(p => p.Domain == domain && p.IsActive);
            //获取工作日历数据:产线的工作日历+默认的工作日历
            calendars = _shopCalendarWorkCtr.Select(p => (lines.Contains(p.ProdLine) || string.IsNullOrEmpty(p.ProdLine)) && p.Domain == domain && p.IsActive);
            //获取产线休息记录数据
            qualityLines = _qualityLineWorkDetail.Select(p => lines.Contains(p.ProdLine) && p.Domain == domain && p.IsActive);
            //外协采购订单
            var pur = _purOrdMaster.Select(p => p.Potype == "PW" && workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd)).ToList();
            List<string> purs = pur?.Select(p => p.PurOrd).Distinct().ToList();
            var purd = _purOrdDetail.Select(p => purs.Contains(p.PurOrd)).ToList();
            //历史排产记录
            List<ScheduleResultOpMaster> previouslyOP = _scheduleResultOpMaster.Select(s => workOrds.Select(m => m.WorkOrd).Contains(s.WorkOrd) && s.WorkEndTime < scheTime.Date);
            //获取节假日记录数据
            holidays = _holidayMaster.Select(p => p.Domain == domain && p.IsActive && p.Dated >= scheTime.Date);
            //获取工单的准备开始时间记录
            timeRecords = _workOrdSetupTimeRecord.Select(p=>p.Domain == domain && workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd));

            //获取当天的生产周期数据
            List<PeriodSequenceDet> dbPeriodSequences = _periodSequenceDet.Select(p => lines.Contains(p.Line) && p.PlanDate == scheTime.Date && p.Domain == domain && p.IsActive);
            //获取当前日期往后的排产记录数据
            List<ScheduleResultOpMaster> dbSchedules = _scheduleResultOpMaster.Select(p => lines.Contains(p.Line) && p.WorkDate == scheTime.Date && p.Domain == domain);

            //排产前校验
            List<ScheduleExceptionMaster> exceptions = BeforeScheduleCheck(workOrds, workOrdRoutings, prodLines,type);
            //过滤校验未通过的工单
            if (exceptions.Any())
            {
                workOrds = workOrds.Where(p => !exceptions.Select(m => m.WorkOrd).Contains(p.WorkOrd)).ToList();
            }
            //修改工序需求数为最大完成数+齐套数量
            workOrds.ForEach(w => {
                w.QtyOrded = w.LocationStock.GetValueOrDefault() + w.OpQtyCompleted.GetValueOrDefault() > w.QtyOrded ? w.QtyOrded : Math.Ceiling(w.LocationStock.GetValueOrDefault() + w.OpQtyCompleted.GetValueOrDefault());
                var routings = workOrdRoutings.Where(r => r.WorkOrd == w.WorkOrd).ToList();
                routings.ForEach(r => {
                    r.QtyOrded = w.LocationStock + w.OpQtyCompleted > w.QtyOrded ? w.QtyOrded : w.LocationStock + w.OpQtyCompleted;
                });
            });
            //3、排产
            //生产周期
            List<PeriodSequenceDet> periodSequenceDtls = new List<PeriodSequenceDet>();
            //排产记录表
            List<ScheduleResultOpMaster> scheduleMasters = new List<ScheduleResultOpMaster>();
            //记录排产结果
            List<ScheduleResultOpMaster> allResults = new List<ScheduleResultOpMaster>();
            //按照优先级排序
            workOrds = workOrds.OrderBy(p=>p.Priority).ToList();

            var scheduleControl = _productScheduleControl.Select().FirstOrDefault();

            var waitWork = workOrds.Where(w => !string.IsNullOrEmpty(w.WorkOrd)).ToList();

            for (int i = 0; i < workOrds.Count; i++)
            {
                //记录产线占用情况
                allResults.AddRange(scheduleMasters);
                //当前工单工艺路线主产线的关键工序
                var curRoutings = workOrdRoutings.Where(p => p.WorkOrd == workOrds[i].WorkOrd && p.ItemNum == workOrds[i].ItemNum && p.ParentOp == 0 && p.MilestoneOp).OrderBy(p => p.OP).ToList();
                //当前工单的产线明细
                var curProdLines = prodLines.Where(p => p.Part == workOrds[i].ItemNum).ToList();
                //当前工单的物料主数据
                var itemlist = itemMasters.Where(p => p.ItemNum == workOrds[i].ItemNum).ToList();
                var check = new ItemMaster();
                if (!itemlist.Any())
                {
                    ScheduleExceptionMaster entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrds[i].Domain;
                    entity.WorkOrd = workOrds[i].WorkOrd;
                    entity.ItemNum = workOrds[i].ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = "排产异常：工单主物料在物料主数据中不存在，请维护后再操作！";
                    entity.Type = type == 1 ? "自动排产" : "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                    continue;
                }
                else
                {
                    check = itemMasters.First(p => p.ItemNum == workOrds[i].ItemNum);
                }
                //产线排产
                LineSchedule(workOrds[i], curRoutings, curProdLines, periodSequenceDtls, scheduleMasters, allResults, exceptions, previouslyOP,pur,purd, true, true);
                waitWork.Remove(workOrds[i]);
                if (scheduleMasters.Count > 0)
                {
                    var isy = scheduleMasters.Where(s => s.WorkOrd == workOrds[i].WorkOrd).Count() > 0;
                    //当前工单未排产
                    if (!isy) { continue; }
                    var endTime = scheduleMasters.Where(s => s.WorkOrd == workOrds[i].WorkOrd).Max(s => s.WorkEndTime);
                    //换型优先级提前排产工单
                    var advanceWorkOrdNo = GetShortSetUpTimeWorkOrdNo(endTime, workOrds[i], curRoutings, curProdLines, waitWork, workOrdRoutings, prodLines);
                    if (!string.IsNullOrEmpty(advanceWorkOrdNo))
                    {
                        var advanceWorkOrd = workOrds.Where(w => w.WorkOrd == advanceWorkOrdNo).FirstOrDefault();
                        if (advanceWorkOrd != null && i != workOrds.Count - 1)
                        {
                            var curWork = workOrds[i];
                            //更改顺序为下一个
                            workOrds.Remove(advanceWorkOrd);
                            var index = workOrds.IndexOf(curWork);
                            i = index;
                            workOrds.Insert(index + 1, advanceWorkOrd);
                        }
                    }
                }
            }
            //回写工单优先级
            foreach (var item in workOrds)
            {
                var curInfo = dbWorkOrds.FirstOrDefault(p => p.WorkOrd == item.WorkOrd);
                if (curInfo != null)
                {
                    //item.Priority = curInfo.Priority;
                    item.QtyOrded = curInfo.QtyOrded;
                }
            }
            
            //更新当天日计划的计划数量，排产数量
            foreach (var item in periodSequenceDtls)
            {
                //item.UDeci5 = item.OrdQty;
                //获取历史排产数据
                var curDtl = dbPeriodSequences.FirstOrDefault(p =>p.OrdQty > 0 && p.Op == item.Op && p.WorkOrds == item.WorkOrds && p.Line == item.Line && p.PlanDate == item.PlanDate && p.PlanDate == scheTime.Date);
                //item.OrdQty = curDtl == null ? item.OrdQty : curDtl.OrdQty;
                item.UDeci5 = curDtl == null ? item.OrdQty : curDtl.OrdQty;
            }

            using (TransactionScope scope = new TransactionScope())
            {
                try
                {
                    //记录排产异常数据
                    if (exceptions.Any())
                    {
                        _scheduleExceptionMaster.Insert(exceptions);
                    }
                    //更新工单优先级
                    _workOrdMaster.Update(workOrds);
                    //添加工单工序准备开始时间记录
                    if (inserts.Any())
                    {
                        _workOrdSetupTimeRecord.Insert(inserts);
                    }
                    //更新工单工序准备开始时间记录
                    if (updates.Any())
                    {
                        _workOrdSetupTimeRecord.Update(updates);
                    }
                    //已投产的工单，只需要保存当前日期下一天的排产记录
                    List<string> sczWorkords = workOrds.Where(p => p.Status.ToUpper() == "W" || p.Status.ToUpper() == "S").Select(p=>p.WorkOrd).ToList();
                    if (sczWorkords.Any())
                    {
                        //获取计划日期在当前日期之后且已投产的日计划,将其计划开工日期改为当天
                        List<PeriodSequenceDet> wlSequenceDets = _periodSequenceDet.Select(p => p.Domain == domain && sczWorkords.Contains(p.WorkOrds) && p.PlanDate > scheTime.Date).ToList();
                        List<ScheduleResultOpMaster> wlSchedules = _scheduleResultOpMaster.Select(p => p.Domain == domain && sczWorkords.Contains(p.WorkOrd) && p.WorkDate > scheTime.Date).ToList();
                        //获取当天的日计划
                        List<PeriodSequenceDet> dtSequenceDets = _periodSequenceDet.Select(p => p.Domain == domain && sczWorkords.Contains(p.WorkOrds) && p.PlanDate == scheTime.Date).ToList();
                        List<ScheduleResultOpMaster> dtScheduleResults = _scheduleResultOpMaster.Select(p => p.Domain == domain && sczWorkords.Contains(p.WorkOrd) && p.WorkDate == scheTime.Date).ToList();
                        //需要更新的日计划
                        List<PeriodSequenceDet> upSequenceDets = new List<PeriodSequenceDet>();
                        List<ScheduleResultOpMaster> upScheduleResults = new List<ScheduleResultOpMaster>();
                        //需要删除的日计划
                        List<PeriodSequenceDet> delSequenceDets = new List<PeriodSequenceDet>();
                        List<ScheduleResultOpMaster> delScheduleResults = new List<ScheduleResultOpMaster>();
                        //需要新增的日计划
                        List<PeriodSequenceDet> inSequenceDets = new List<PeriodSequenceDet>();
                        List<ScheduleResultOpMaster> inScheduleResults = new List<ScheduleResultOpMaster>();
                        PeriodSequenceDet seqInfo = new PeriodSequenceDet();
                        ScheduleResultOpMaster schInfo = new ScheduleResultOpMaster();
                        foreach (var gdh in sczWorkords)
                        {
                            //提前投产的日计划
                            var tcSeqs = wlSequenceDets.Where(p => p.WorkOrds == gdh && (p.Status.ToUpper() == "W" || p.Status.ToUpper() == "S")).ToList();
                            //当前工单存在未来日期投产的日计划
                            if (tcSeqs.Any())
                            {
                                //获取提前投产的工序
                                List<int> ops = tcSeqs.Select(p => p.Op).Distinct().ToList();
                                foreach (var op in ops)
                                {
                                    //当前工序提前投产的日计划
                                    var opSeqs = tcSeqs.Where(p => p.Op == op).ToList();
                                    //获取当天的日计划
                                    var dtSeq = dtSequenceDets.FirstOrDefault(p=>p.WorkOrds == gdh && p.Op == op);
                                    if (dtSeq != null )
                                    {
                                        delSequenceDets.Add(dtSeq);
                                    }
                                    seqInfo = new PeriodSequenceDet();
                                    seqInfo = opSeqs[0];
                                    seqInfo.OrdQty = opSeqs.Sum(p => p.OrdQty) + (dtSeq != null ? dtSeq.OrdQty : 0m);
                                    seqInfo.CompQty = opSeqs.Sum(p => p.CompQty) + (dtSeq != null ? dtSeq.CompQty : 0m);

                                    //获取提前投产的日计划
                                    var opSchs = wlSchedules.Where(p => p.WorkOrd == gdh && p.Op == op && opSeqs.Select(m => m.PlanDate).Contains(p.WorkDate)).ToList();
                                    if (!opSchs.Any()) continue;
                                    schInfo = opSchs[0];
                                    string strScheTime = scheTime.Date.ToString("yyyy-MM-dd");
                                    schInfo.WorkDate = scheTime.Date;
                                    schInfo.WorkQty = seqInfo.OrdQty;
                                    schInfo.WorkStartTime = Convert.ToDateTime(schInfo.WorkStartTime.ToString("yyyy-MM-dd HH:mm:ss").Replace(schInfo.WorkStartTime.ToString("yyyy-MM-dd"), strScheTime));
                                    schInfo.WorkEndTime = Convert.ToDateTime(schInfo.WorkEndTime.ToString("yyyy-MM-dd HH:mm:ss").Replace(schInfo.WorkEndTime.ToString("yyyy-MM-dd"), strScheTime));
                                    upScheduleResults.Add(schInfo);
                                    //获取当天的日计划
                                    var dtSch = dtScheduleResults.FirstOrDefault(p=>p.WorkOrd == gdh && p.Op == op);
                                    if (dtSch != null)//当天有日计划
                                    {
                                        delScheduleResults.Add(dtSch);
                                    }

                                    seqInfo.PlanDate = scheTime.Date;
                                    upSequenceDets.Add(seqInfo);
                                }
                            }
                            
                            //今天未投产的计划清空
                            var delp = dtSequenceDets.Where(p => string.IsNullOrEmpty(p.Status) && p.WorkOrds==gdh).ToList();
                            if (delp.Any())
                            {
                                //删除今天的
                                delSequenceDets.AddRange(delp);
                                var delr = dtScheduleResults.Where(p => p.WorkOrd == gdh && delp.Select(d => d.Op).Contains(p.Op)).ToList();
                                delScheduleResults.AddRange(delr);
                                //同一个工序有下达记录则不进行新增
                                var pc= dtSequenceDets.Where(p => !string.IsNullOrEmpty(p.Status) && p.WorkOrds == gdh).ToList();
                                delp = delp.Where(d=> !pc.Select(p=>p.Op).Contains(d.Op)).ToList();
                                //新增今天的
                                inSequenceDets.AddRange(periodSequenceDtls.Where(p=>p.WorkOrds==gdh && p.PlanDate== scheTime.Date && delp.Select(d => d.Op).Contains(p.Op)));
                                inScheduleResults.AddRange(scheduleMasters.Where(p => p.WorkOrd == gdh && p.WorkDate == scheTime.Date && delp.Select(d => d.Op).Contains(p.Op)));
                            }
                            //无计划的今天的工序新增
                            var inss = dtScheduleResults.Where(p => p.WorkOrd == gdh).ToList();
                            var ins = periodSequenceDtls.Where(p => p.WorkOrds == gdh && p.PlanDate == scheTime.Date && !inss.Select(n=>n.Op).Contains(p.Op)).ToList();
                            if (ins.Any())
                            {
                                //新增今天的
                                inSequenceDets.AddRange(ins);
                                inScheduleResults.AddRange(scheduleMasters.Where(p => p.WorkOrd == gdh && p.WorkDate == scheTime.Date && ins.Select(d => d.Op).Contains(p.Op)));
                            }
                        }
                        //更新提前投产的日计划
                        if (upSequenceDets.Any())
                        {
                            _periodSequenceDet.Update(upSequenceDets);
                        }
                        if (upScheduleResults.Any())
                        {
                            _scheduleResultOpMaster.Update(upScheduleResults);
                        }
                        //删除当天的日计划
                        if (delSequenceDets.Any())
                        {
                            _periodSequenceDet.Delete(delSequenceDets);
                        }
                        if (delScheduleResults.Any())
                        {
                            _scheduleResultOpMaster.Delete(delScheduleResults);
                        }
                        //新增当天的日计划
                        if (inSequenceDets.Any())
                        {
                            _periodSequenceDet.Insert(inSequenceDets);
                        }
                        if (inScheduleResults.Any())
                        {
                            _scheduleResultOpMaster.Insert(inScheduleResults);
                        }
                        //删除当前日期下一天开始的工单排产记录
                        _periodSequenceDet.Delete(p => sczWorkords.Contains(p.WorkOrds) && p.PlanDate > scheTime.Date && p.Domain == domain);
                        _scheduleResultOpMaster.Delete(p => sczWorkords.Contains(p.WorkOrd) && p.WorkDate > scheTime.Date && p.Domain == domain);

                        //保存下一天的日计划数据
                        _periodSequenceDet.Insert(periodSequenceDtls.Where(p => sczWorkords.Contains(p.WorkOrds) && p.PlanDate > scheTime.Date).ToList());
                        _scheduleResultOpMaster.Insert(scheduleMasters.Where(p => sczWorkords.Contains(p.WorkOrd) && p.WorkDate > scheTime.Date).ToList());

                    }
                    //未投产的工单，当前日期及以后的排产记录全部删除
                    List<string> wscWorkords = workOrds.Where(p => p.Status.ToUpper() != "W" && p.Status.ToUpper() != "S").Select(p => p.WorkOrd).ToList();
                    if (wscWorkords.Any())
                    {
                        //删除当前日期及以后的工单排产记录
                        _periodSequenceDet.Delete(p => wscWorkords.Contains(p.WorkOrds) && p.PlanDate >= scheTime.Date && p.Domain == domain && p.OrdQty != 0);
                        _scheduleResultOpMaster.Delete(p => wscWorkords.Contains(p.WorkOrd) && p.WorkDate >= scheTime.Date && p.Domain == domain);

                        //保存当前日期及以后的日计划数据
                        var ins1 = periodSequenceDtls.Where(p => wscWorkords.Contains(p.WorkOrds) && p.PlanDate >= scheTime.Date).ToList();
                        _periodSequenceDet.Insert(periodSequenceDtls.Where(p => wscWorkords.Contains(p.WorkOrds) && p.PlanDate >= scheTime.Date).ToList());
                        var ins2 = scheduleMasters.Where(p => wscWorkords.Contains(p.WorkOrd) && p.WorkDate >= scheTime.Date).ToList();
                        _scheduleResultOpMaster.Insert(scheduleMasters.Where(p => wscWorkords.Contains(p.WorkOrd) && p.WorkDate >= scheTime.Date).ToList());
                    }
                    scope.Complete();
                }
                catch (Exception ex)
                {
                    new NLogHelper("ProductionScheduleAppService").WriteLog("DoProductSchedule", "保存排产数据失败：" + ex.Message, _currentTenant.Id.ToString());
                    scope.Dispose();
                    return "NO|排产数据保存失败";
                }
            }

            //领料单重新处理
            AdjustNbrDate(workOrds);
            //日计划自动下达
            await ProductionDailyPlanAutoPublish(domain);
            return "OK";
        }

        //换型最短工单优先排产
        public string GetShortSetUpTimeWorkOrdNo(DateTime startTime, WorkOrdMaster workOrd, List<WorkOrdRouting> curRoutings, List<ProdLineDetail> curProdLines, List<WorkOrdMaster> workOrds, List<WorkOrdRouting> workOrdRoutings, List<ProdLineDetail> prodLines)
        {
            //三天内的工单
            var scopeWork = workOrds.Where(p => p.OrdDate >= startTime && p.OrdDate <= startTime.AddDays(3) && p.Priority > workOrd.Priority).ToList();
            if (scopeWork.Any())
            {
                //相同物料的工单
                var equalWork = scopeWork.Where(p => p.ItemNum == workOrd.ItemNum).OrderBy(p => p.Priority).FirstOrDefault();
                if (equalWork == null)
                {
                    //三天范围内工序
                    var scopeWorkNo = scopeWork.Select(p => p.WorkOrd).ToList();
                    var scopeRoutings = workOrdRoutings.Join(prodLines, r => new { ItemNum = r.ItemNum, OP = r.OP }, p => new { ItemNum = p.Part, OP = p.Op }, (r, p) => new { r, p.InternalEquipmentCode, p.MoldTypeCode, p.SetupTime }).Where(n => scopeWorkNo.Contains(n.r.WorkOrd)).ToList();
                    if (!scopeRoutings.Any()) { return ""; }
                    //本工单所有模具
                    var molds = curProdLines.Where(c => !string.IsNullOrEmpty(c.MoldTypeCode)).Select(c => c.MoldTypeCode).Distinct().ToList();
                    if (!molds.Any()) { return ""; }
                    //删除相同模具的准备时间
                    scopeRoutings.RemoveAll(r => molds.Contains(r.MoldTypeCode));
                    if (!scopeRoutings.Any()) { return ""; }
                    //计算剩下工序的总准备时间，取出最小值
                    var routings = scopeRoutings.GroupBy(s => s.r.WorkOrd).Select(g => new { WorkOrd = g.Key, SumTime = g.Sum(p => p.SetupTime) }).OrderBy(g => g.SumTime).ToList();
                    equalWork = scopeWork.Where(s => s.WorkOrd == routings[0].WorkOrd).First();
                    //物料不一样但工序一样导致全部删除的工单换型时间为0
                    if (routings.Count < scopeWorkNo.Count && scopeWorkNo.Count > 0 && routings.Count > 0)
                    {
                        var works = routings.Select(p => p.WorkOrd).ToList();
                        scopeWorkNo.RemoveAll(p => works.Contains(p));
                        equalWork = workOrds.Where(w => scopeWorkNo.Contains(w.WorkOrd)).OrderBy(w => w.Priority).First();
                    }
                }
                return equalWork == null ? "" : equalWork.WorkOrd;
            }
            return "";
        }


        /// <summary>
        /// 排产前校验
        /// </summary>
        /// <param name="workOrds">待排产工单</param>
        /// <param name="workOrdRoutings">工单工艺路线</param>
        /// <param name="prodLines">产线明细</param>
        /// <param name="type">排产类型：1-自动排产，2-手动排产</param>
        /// <returns></returns>
        public List<ScheduleExceptionMaster> BeforeScheduleCheck(List<WorkOrdMaster> workOrds,List<WorkOrdRouting> workOrdRoutings, List<ProdLineDetail> prodLines,int type) 
        {
            //记录操作时间
            string optTime = DateTime.Now.ToString("yyyyMMddHHmmss");
            List<ScheduleExceptionMaster> exceptions = new List<ScheduleExceptionMaster>();
            ScheduleExceptionMaster entity;
            foreach (var item in workOrds)
            {
                var curRoutings = workOrdRoutings.Where(p => p.WorkOrd == item.WorkOrd && p.ItemNum == item.ItemNum && p.MilestoneOp).OrderBy(p=>p.OP).Select(p=>p.OP).ToList();
                //判断当前工单主产线是否设置了关键工序
                if (!curRoutings.Any())//当前工单没有维护关键工序
                {
                    entity = new ScheduleExceptionMaster();
                    entity.Domain = item.Domain;
                    entity.WorkOrd = item.WorkOrd;
                    entity.ItemNum = item.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = "排产异常：工单的工艺路线没有维护关键工序，请维护后再操作！";
                    entity.Type = type == 1 ? "自动排产" : "手动排产";
                    entity.OptTime = optTime;
                    exceptions.Add(entity);
                    continue;
                }
                //获取当前工单物料对应的产线信息
                var lineDetails = prodLines.Where(x => x.Part == item.ItemNum && curRoutings.Contains(x.Op)).ToList();
                if (!lineDetails.Any())
                {
                    entity = new ScheduleExceptionMaster();
                    entity.Domain = item.Domain;
                    entity.WorkOrd = item.WorkOrd;
                    entity.ItemNum = item.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = "排产异常：工单的关键工序没有维护产线数据，请维护后再操作！";
                    entity.Type = type == 1 ? "自动排产" : "手动排产";
                    entity.OptTime = optTime;
                    exceptions.Add(entity);
                    continue;
                }
                //校验关键工序是否维护了产线
                List<LineStartDto> lines = new List<LineStartDto>();
                foreach (var op in curRoutings)
                {
                    var curLines = lineDetails.Where(p => p.Op == op).ToList();
                    if (!curLines.Any())//当前Op没有维护产线
                    {
                        entity = new ScheduleExceptionMaster();
                        entity.Domain = item.Domain;
                        entity.WorkOrd = item.WorkOrd;
                        entity.ItemNum = item.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = "排产异常：工单的关键工序["+ op + "]没有维护产线数据，请维护后再操作！";
                        entity.Type = type == 1 ? "自动排产" : "手动排产";
                        entity.OptTime = optTime;
                        exceptions.Add(entity);
                    }
                    foreach (var line in curLines)
                    {
                        lines.Add(new LineStartDto { 
                            Line = line.Line,
                            Op = op
                        });
                    }
                }
                //校验一条产线是否维护了多个关键工序
                List<string> pdLines = lines.Select(p => p.Line).Distinct().ToList();
                foreach (var line in pdLines)
                {
                    var curLines = lines.Where(p => p.Line == line).ToList();
                    if (curLines.Count() > 1)//当前物料的多个关键工序对应一条产线
                    {
                        entity = new ScheduleExceptionMaster();
                        entity.Domain = item.Domain;
                        entity.WorkOrd = item.WorkOrd;
                        entity.ItemNum = item.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = "排产异常：工单的多个关键工序[" + string.Join("、",curLines.Select(p=>p.Op).ToList()) + "]对应同一条产线[" + curLines[0].Line +"]，请调整后再操作！";
                        entity.Type = type == 1 ? "自动排产" : "手动排产";
                        entity.OptTime = optTime;
                        exceptions.Add(entity);
                    }
                }

                //获取当前工单物料对应的产线信息
                var curRoutingss = workOrdRoutings.Where(p => p.WorkOrd == item.WorkOrd && p.ItemNum == item.ItemNum && p.MilestoneOp && p.ProcessOut != 1).ToList();
                lineDetails = prodLines.Where(x => x.Part == item.ItemNum && curRoutingss.Select(c => c.OP).ToList().Contains(x.Op)).ToList();
                if (exceptions.FindIndex(e => e.WorkOrd == item.WorkOrd) < 0)
                {
                    if (!lineDetails.Any() || lineDetails?.Count == 0)
                    {
                        //产线物料中找不到时检查工单工序表是否有维护
                        var curRoutingsOp = workOrdRoutings.Where(r => curRoutingss.Select(c => c.OP).ToList().Contains(r.OP) && r.MachBdnRate != 0 && (r.WorkCode != "P" && !string.IsNullOrEmpty(r.Machine) || r.WorkCode == "P")).ToList();
                        if (!curRoutingsOp.Any() || curRoutingsOp?.Count == 0)
                        {
                            entity = new ScheduleExceptionMaster();
                            entity.Domain = item.Domain;
                            entity.WorkOrd = item.WorkOrd;
                            entity.ItemNum = item.ItemNum;
                            entity.CreateTime = DateTime.Now;
                            entity.Remark = "排产异常：工单的关键工序没有维护产线数据，请维护后再操作！";
                            entity.Type = type == 1 ? "自动排产" : "手动排产";
                            entity.OptTime = optTime;
                            exceptions.Add(entity);
                            continue;
                        }
                        else
                        {
                            var Routings = curRoutingsOp.Where(p => (p.WorkCode != "P" && string.IsNullOrEmpty(p.Machine)) || (p.Engineer != "" && p.Engineer != "/" && p.RunCrew == 0)).ToList();
                            if (Routings.Any())
                            {
                                entity = new ScheduleExceptionMaster();
                                entity.Domain = item.Domain;
                                entity.WorkOrd = item.WorkOrd;
                                entity.ItemNum = item.ItemNum;
                                entity.CreateTime = DateTime.Now;
                                entity.Remark = "排产异常：工单的关键工序没有维护产线数据，请维护后再操作！";
                                entity.Type = type == 1 ? "自动排产" : "手动排产";
                                entity.OptTime = optTime;
                                exceptions.Add(entity);
                                continue;
                            }
                        }
                    }
                    else
                    {
                        var line = lineDetails.Where(p => (p.OpType != "P" && string.IsNullOrEmpty(p.InternalEquipmentCode)) || (p.SkillNo != "" && p.SkillNo != "/" && p.StandardStaffCount == 0)).ToList();
                        if (line.Any())
                        {
                            entity = new ScheduleExceptionMaster();
                            entity.Domain = item.Domain;
                            entity.WorkOrd = item.WorkOrd;
                            entity.ItemNum = item.ItemNum;
                            entity.CreateTime = DateTime.Now;
                            entity.Remark = "排产异常：工单的关键工序没有维护产线数据，请维护后再操作！";
                            entity.Type = type == 1 ? "自动排产" : "手动排产";
                            entity.OptTime = optTime;
                            exceptions.Add(entity);
                            continue;
                        }
                    }
                }
                //校验主产线关键工序对应的产线是否维护了工作日历
                var curCalendars = calendars.Where(x => lineDetails.Select(p => p.Line).Contains(x.ProdLine) || string.IsNullOrEmpty(x.ProdLine)).ToList();
                foreach (var rut in lineDetails)
                {
                    //获取当前产线维护的工作日历
                    var lineCals = curCalendars.Where(p => p.ProdLine == rut.Line).ToList();
                    if (!lineCals.Any())//当前产线未维护工作日历
                    {
                        lineCals = calendars.Where(p => string.IsNullOrEmpty(p.ProdLine)).ToList();
                        if (!lineCals.Any() || lineCals.Select(p => p.WeekDay).Distinct().Count() != 7)
                        {
                            entity = new ScheduleExceptionMaster();
                            entity.Domain = item.Domain;
                            entity.WorkOrd = item.WorkOrd;
                            entity.ItemNum = item.ItemNum;
                            entity.CreateTime = DateTime.Now;
                            entity.Remark = "排产异常：产线["+rut.Line+ "]没有维护工作日历且标准工作日历未维护完全，请维护后再操作！";
                            entity.Type = type == 1 ? "自动排产" : "手动排产";
                            entity.OptTime = optTime;
                            exceptions.Add(entity);
                        }
                    }
                    else if (lineCals.Select(p => p.WeekDay).Distinct().Count() != 7)//当前产线维护了工作日历，但是没有维护完全
                    {
                        entity = new ScheduleExceptionMaster();
                        entity.Domain = item.Domain;
                        entity.WorkOrd = item.WorkOrd;
                        entity.ItemNum = item.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = "排产异常：产线[" + rut.Line + "]工作日历没有维护完整，请维护后再操作！";
                        entity.Type = type == 1 ? "自动排产" : "手动排产";
                        entity.OptTime = optTime;
                        exceptions.Add(entity);
                    }
                }
            }
            return exceptions;
        }

        /// <summary>
        /// 排产
        /// </summary>
        /// <param name="workOrd">工单</param>
        /// <param name="workOrdRoutings">当前工单的工艺路线的关键工序(有几个关键工序就有几条产线)</param>
        /// <param name="prodLines">当前工单的产线明细</param>
        /// <param name="periodsDet">生产周期</param>
        /// <param name="scheduleResults">排产结果</param>
        /// <param name="allResults">产线占用记录</param>
        public void LineSchedule(WorkOrdMaster workOrd, List<WorkOrdRouting> workOrdRoutings, List<ProdLineDetail> prodLines,List<PeriodSequenceDet> periodsDet, List<ScheduleResultOpMaster> scheduleResults, List<ScheduleResultOpMaster> allResults, List<ScheduleExceptionMaster> exceptions, List<ScheduleResultOpMaster> previouslyOP,List<PurOrdMaster> pur,List<PurOrdDetail> purd, bool Check = false, bool UseSkill = true)
        {
            //生产周期
            List<PeriodSequenceDet> curSequences = new List<PeriodSequenceDet>();
            //排产明细
            List<ScheduleResultOpMaster> curScheduleRsts = new List<ScheduleResultOpMaster>();
            //记录上一产线排产开始时间
            LineStartDto lineStart = new LineStartDto();
            //产线开工时间默认为当前时间
            lineStart.StartTime = scheTime;
            TimeSpan span = TimeSpan.Zero;
            var remainNum = 0m;
            //第一层级工序有几个关键工序，就有几条产线
            for (int i = 0; i < workOrdRoutings.Count; i++)
            {
                var Maxednum = 0;
                List<ScheduleResultOpMaster> LastcurScheduleRsts = new List<ScheduleResultOpMaster>();
                //获取工序对应的产线,根据优先级排序
                var lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == workOrdRoutings[i].OP && p.Bom == workOrd.Refs).OrderBy(p => p.Sequence).ToList();
                //没有对应工艺且工序表无记录
                if (!lines.Any() && workOrdRoutings[i].MachBdnRate == 0)
                {
                    lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == workOrdRoutings[i].OP).OrderBy(p => p.Sequence).ToList();
                }
                var Line = !string.IsNullOrEmpty(workOrdRoutings[i].ProdLine) ? workOrdRoutings[i].ProdLine : (lines.Count > 0 ? lines[0].Line : workOrdRoutings[i].ProdLine);
                //当前产线的工作日历
                var mLCalendars = calendars.Where(p => p.WorkCtr == Line || string.IsNullOrEmpty(p.ProdLine)).ToList();
                //当前产线的休息时间设置
                var mlqtyWorkDtls = qualityLines.Where(p => p.ProdLine == Line).ToList();
                var Rate = workOrdRoutings[i].MachBdnRate > 0 ? workOrdRoutings[i].MachBdnRate : (lines.Count > 0 ? lines[0].Rate : workOrdRoutings[i].MachBdnRate);
                var OpType = !string.IsNullOrEmpty(workOrdRoutings[i].WorkCode) ? workOrdRoutings[i].WorkCode : (lines.Count > 0 ? lines[0].OpType : workOrdRoutings[i].WorkCode);
                decimal ScaleNum = 1m;
                if (!Check && lineStart.Rate < Rate && lineStart.Rate != 0 && i != 0)
                {
                    ScaleNum = lineStart.Rate / Rate;
                }
                //var lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == workOrdRoutings[i].OP).OrderBy(p => p.Sequence).ToList();
                //外协工序特殊处理，不进入产能计算
                if (workOrdRoutings[i].ProcessOut == 1)
                {
                    //对应外协采购订单
                    var curpur = pur.Where(p => p.Potype == "PW" && p.WorkOrd == workOrd.WorkOrd).First();
                    List<string> purs = pur?.Select(p => p.PurOrd).Distinct().ToList();
                    PurOrdDetail curpurd = purd.Where(p => purs.Contains(p.PurOrd) && p.ItemNum == workOrdRoutings[i].ItemNum && p.Op == workOrdRoutings[i].OP).Count() > 0 ? _purOrdDetail.Select(p => purs.Contains(p.PurOrd) && p.ItemNum == workOrdRoutings[i].ItemNum && p.Op == workOrdRoutings[i].OP).First() : null;
                    //前序排产记录
                    LastcurScheduleRsts = curScheduleRsts?.Where(c => c.Op == lineStart.Op).ToList();
                    //如果有采购订单则取订单日期，没有则取上序的开始时间，再没有则取当前日期
                    //DateTime StartTime = purd != null ? pur.Where(p => p.PurOrd == purd.PurOrd).First().OrdDate.GetValueOrDefault() :
                    DateTime StartTime = LastcurScheduleRsts != null && LastcurScheduleRsts.Count > 0 ? LastcurScheduleRsts[LastcurScheduleRsts.Count - 1].WorkStartTime : scheTime;
                    //判断是否工作日
                    var isworkday = CheckIsWorkDay(StartTime);
                    while (!isworkday)
                    {
                        StartTime = StartTime.AddDays(1);
                        isworkday = CheckIsWorkDay(StartTime);
                    }
                    var line = pur.Count > 0 ? pur.Where(p => p.PurOrd == curpur.PurOrd).First().Supp : workOrdRoutings[i].ProcessOutSupp;
                    var qty = purd != null ? curpurd.QtyOrded : workOrd.QtyOrded;
                    //记录生产周期
                    curSequences.Add(new PeriodSequenceDet
                    {
                        Domain = domain,
                        Line = line,
                        ItemNum = workOrd.ItemNum,
                        PlanDate = StartTime.Date,
                        Period = 1,
                        OrdQty = qty,
                        WorkOrds = workOrd.WorkOrd,
                        Op = workOrdRoutings[i].OP,
                        IsActive = true,
                        Status = "",
                        CreateTime = DateTime.Now,
                        UDate2 = StartTime
                    });
                    //记录排产记录
                    curScheduleRsts.Add(new ScheduleResultOpMaster
                    {
                        Domain = domain,
                        WorkOrd = workOrd.WorkOrd,
                        WorkCtr = "",
                        OpDescr = workOrdRoutings[i].Descr,
                        Line = line,
                        ItemNum = workOrd.ItemNum,
                        Op = workOrdRoutings[i].OP,
                        WorkDate = StartTime.Date,
                        WorkQty = qty,
                        WorkStartTime = StartTime,
                        WorkEndTime = curpurd != null ? (curpurd.DueDate.GetValueOrDefault() < StartTime.Date ? StartTime.AddDays(7) : curpurd.DueDate.GetValueOrDefault()) : StartTime.AddDays(7),//默认七天后到
                        CreateTime = DateTime.Now,
                        WorkActivateTime = StartTime,
                        SetupTime = 0,
                        DeviceAllocationCount = 0,
                        InternalEquipmentCode = "",
                        MoldTypeCode = "",
                        MoldAllocationCount = 0
                    });
                    //修改后序开始时间
                    lineStart.QtyRemain = qty;
                    lineStart.StartTime = StartTime;
                    lineStart.OneQty = qty;
                    lineStart.Op = workOrdRoutings[i].OP;
                    lineStart.Line = line;
                    lineStart.Rate = qty;
                    lineStart.setupTime = 0;
                    lineStart.WaitTime = 0;
                    continue;
                }
                //委外工序两边不同步
                if (OpType == "M" && Rate == 0)
                {
                    var entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrd.Domain;
                    entity.WorkOrd = workOrd.WorkOrd;
                    entity.ItemNum = workOrd.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-机器工序未维护单位产能！";
                    entity.Type = "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                    return;
                }
                if (OpType == "P" && Rate == 0)
                {
                    var entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrd.Domain;
                    entity.WorkOrd = workOrd.WorkOrd;
                    entity.ItemNum = workOrd.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-人工工序未维护单位产能！";
                    entity.Type = "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                    return;
                }
                if (Rate == 0)
                {
                    var entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrd.Domain;
                    entity.WorkOrd = workOrd.WorkOrd;
                    entity.ItemNum = workOrd.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-工序未维护单位产能！";
                    entity.Type = "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                    return;
                }
                //产线实际排产开始时间
                if (i == 0)//第一条产线
                {
                    lineStart = DealStartTime(workOrd, workOrdRoutings[i], lines, allResults, exceptions, mLCalendars, mlqtyWorkDtls, Check, UseSkill);
                    //var s = _scheduleResultOpMaster.Select(p => p.WorkOrd == workOrd.WorkOrd).ToList();
                    if (lineStart.equipmentNum == 0 && lineStart.OpType != "P" && exceptions.FindIndex(e => e.WorkOrd == workOrd.WorkOrd) < 0)
                    {
                        var entity = new ScheduleExceptionMaster();
                        entity.Domain = workOrd.Domain;
                        entity.WorkOrd = workOrd.WorkOrd;
                        entity.ItemNum = workOrd.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-{lineStart.InternalEquipmentCode}无可用设备！";
                        entity.Type = "手动排产";
                        entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                        exceptions.Add(entity);
                        return;
                    }
                    //工单剩余制程（产能最小的工序使用最低设备数的时长+1天）,排除人工工序和外协工序
                    var minrate = 0m;
                    var rcount = workOrdRoutings.Where(r => r.WorkCode != "P" && r.MachBdnRate > 0).ToList().Count;
                    if (rcount > 0)
                    {
                        minrate = workOrdRoutings.Where(r => r.WorkCode != "P" && r.MachBdnRate > 0).Min(r => r.MachBdnRate);
                    }
                    else
                    {
                        if (prodLines.Where(p => p.Rate > 0).ToList().Count > 0)
                        {
                            rcount = prodLines.Where(p => p.OpType != "P" && p.Rate > 0).ToList().Count;
                            if (rcount > 0)
                            {
                                minrate = prodLines.Where(p => p.OpType != "P" && p.Rate > 0).Min(p => p.Rate);
                            }
                            else
                            {
                                minrate = prodLines.Where(p => p.Rate > 0).Min(p => p.Rate);
                            }
                        }
                        else
                        {
                            rcount = workOrdRoutings.Where(r => r.MachBdnRate > 0).ToList().Count;
                            if (rcount > 0)
                            {
                                minrate = workOrdRoutings.Where(r => r.MachBdnRate > 0).Min(p => p.MachBdnRate);
                            }
                        }
                    }
                    //>0? workOrdRoutings.Where(r => r.WorkCode != "P" && r.MachBdnRate != 0).Min(r=>r.MachBdnRate) : (prodLines.Where(p => p.OpType != "P" && p.Rate != 0).ToList().Count>0?prodLines.Where(p => p.OpType != "P" && p.Rate != 0).Min(p => p.Rate): prodLines.Where(p => p.Rate > 0).Min(p => p.Rate));
                    //var minrate = prodLines.Where(p => p.OpType != "P" && p.Rate != 0).Min(p => p.Rate);
                    var workMaxTime = (lineStart.QtyRemain / minrate) + 24;
                    //工单预计剩余生产天数
                    var wkspan = workOrd.DueDate.GetValueOrDefault() - lineStart.StartTime;
                    if (wkspan.TotalHours < 0)
                    {
                        wkspan = lineStart.StartTime.AddDays(1) - lineStart.StartTime;
                    }
                    var remainDay = ((decimal)wkspan.TotalHours - workMaxTime) / 2;
                    if (remainDay <= 0)
                    {
                        //remainDay = workMaxTime;
                        remainDay = (decimal)wkspan.TotalHours;
                    }
                    //预估每天生产量
                    remainNum = lineStart.QtyRemain / remainDay * 24;
                }
                else
                {
                    decimal lastsumqty = 0m;
                    int j = 0;
                    bool ispc = true;
                    //前序排产记录
                    LastcurScheduleRsts = curScheduleRsts.Where(c => c.Op == lineStart.Op).ToList();
                    if (LastcurScheduleRsts.Count == 0)
                    {
                        var entity = new ScheduleExceptionMaster();
                        entity.Domain = workOrd.Domain;
                        entity.WorkOrd = workOrd.WorkOrd;
                        entity.ItemNum = workOrd.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}前序准备时间未刷新！";
                        entity.Type = "手动排产";
                        entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                        exceptions.Add(entity);
                        return;
                    }
                    //每天所需设备数（向上圆整）
                    Maxednum = OpType == "P" && remainNum > 0 ? Convert.ToInt32(Math.Ceiling(remainNum / (Rate * 24))) : (remainNum <= 0 ? 1 : Convert.ToInt32(Math.Ceiling(remainNum / (Rate * 24) / 2)));
                    //非人工工序要获取可用设备数量
                    if (OpType != "P")
                    {
                        //可用数量
                        var numList = new List<string>();
                        //可插班的明细
                        ScheduleResultOpMaster schedule = null;
                        //维修结束时间
                        DateTime wxEndTime = lineStart.StartTime;
                        LineStartDto startDto = new LineStartDto();
                        startDto.InternalEquipmentCode = !string.IsNullOrEmpty(workOrdRoutings[i].Machine) ? workOrdRoutings[i].Machine : (lines.Count > 0 ? lines[0].InternalEquipmentCode : workOrdRoutings[i].Machine);
                        startDto.MoldTypeCode = !string.IsNullOrEmpty(workOrdRoutings[i].ToolCode) ? workOrdRoutings[i].ToolCode : (lines.Count > 0 ? lines[0].MoldTypeCode : workOrdRoutings[i].ToolCode);
                        startDto.WorkCtr = !string.IsNullOrEmpty(workOrdRoutings[i].WorkCtr) ? workOrdRoutings[i].WorkCtr : (lines.Count > 0 ? (lines[0].Site != workOrdRoutings[i].WorkCtr && !string.IsNullOrEmpty(workOrdRoutings[i].WorkCtr) ? workOrdRoutings[i].WorkCtr : lines[0].Site) : workOrdRoutings[i].WorkCtr);
                        startDto.RecID = lines.Count > 0 ? lines[0].RecID : 0;
                        startDto.Line = !string.IsNullOrEmpty(workOrdRoutings[i].ProdLine) ? workOrdRoutings[i].ProdLine : (lines.Count > 0 ? (lines[0].Line != workOrdRoutings[i].ProdLine && !string.IsNullOrEmpty(workOrdRoutings[i].ProdLine) ? workOrdRoutings[i].ProdLine : lines[0].Line) : workOrdRoutings[i].ProdLine);
                        startDto.setupTime = workOrdRoutings[i].StdSetupTime > 0 ? workOrdRoutings[i].StdSetupTime : (lines.Count > 0 ? lines[0].SetupTime : workOrdRoutings[i].StdSetupTime);
                        startDto.SkillNo = !string.IsNullOrEmpty(workOrdRoutings[i].Engineer) ? workOrdRoutings[i].Engineer : (lines.Count > 0 ? lines[0].SkillNo : workOrdRoutings[i].Engineer);
                        startDto.StandardStaffCount = workOrdRoutings[i].RunCrew > 0 ? workOrdRoutings[i].RunCrew : (lines.Count > 0 ? lines[0].StandardStaffCount : workOrdRoutings[i].RunCrew);
                        startDto.Rate = Rate;
                        startDto.OpType = OpType;
                        startDto.Op = workOrdRoutings[i].OP;
                        //设备可用数量和可用时间
                        AvailableQuantity(workOrd, lineStart.StartTime, startDto, lines, allResults, exceptions, out numList, out schedule, out wxEndTime, UseSkill);
                        Maxednum = numList.Count > 0 ? (numList[0].ToInt() > Maxednum ? Maxednum : numList[0].ToInt()) : Maxednum;
                    }
                    //true:按班次，false:按小时
                    var hourNum = Check ? 8 : 1;
                    var NowQty = lines.Count > 0 ? Maxednum * lines[0].Rate * hourNum * ScaleNum : Maxednum * workOrdRoutings[i].MachBdnRate * hourNum * ScaleNum;

                    while (ispc)
                    {
                        //前序满足本序产量
                        lineStart.StartTime = j >= LastcurScheduleRsts.Count ? LastcurScheduleRsts[j - 1].WorkEndTime : LastcurScheduleRsts[j].WorkEndTime;
                        lastsumqty += j == LastcurScheduleRsts.Count ? LastcurScheduleRsts[j - 1].WorkQty : LastcurScheduleRsts[j].WorkQty;
                        if (lastsumqty > NowQty || j == LastcurScheduleRsts.Count || i == workOrdRoutings.Count - 1)
                        {
                            if (!Check)
                            {
                                var hours = Math.Ceiling(NowQty / lineStart.Rate);
                                lineStart.StartTime = j == LastcurScheduleRsts.Count ? (LastcurScheduleRsts[j - 1].WorkEndTime > LastcurScheduleRsts[j - 1].WorkActivateTime.AddHours((double)hours) ? LastcurScheduleRsts[j - 1].WorkActivateTime.AddHours((double)hours) : LastcurScheduleRsts[j - 1].WorkEndTime) : (LastcurScheduleRsts[j].WorkEndTime > LastcurScheduleRsts[j].WorkActivateTime.AddHours((double)hours) ? LastcurScheduleRsts[j].WorkActivateTime.AddHours((double)hours) : LastcurScheduleRsts[j].WorkEndTime);
                            }
                            lineStart = DealNextStartTime(workOrd, lineStart, workOrdRoutings[i], lines, allResults, calendars, exceptions, mLCalendars, mlqtyWorkDtls, Check, UseSkill);
                            ispc = false;
                        }
                        j++;
                    }
                    if (lineStart.equipmentNum == 0 && lineStart.OpType != "P" && exceptions.FindIndex(e => e.WorkOrd == workOrd.WorkOrd) < 0)
                    {
                        var entity = new ScheduleExceptionMaster();
                        entity.Domain = workOrd.Domain;
                        entity.WorkOrd = workOrd.WorkOrd;
                        entity.ItemNum = workOrd.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-{lineStart.InternalEquipmentCode}无可用设备！";
                        entity.Type = "手动排产";
                        entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                        exceptions.Add(entity);
                        return;
                    }
                }
                if (exceptions.FindIndex(e => e.WorkOrd == workOrd.WorkOrd) >= 0)
                {
                    return;
                }
                //如果当前工序已经生产完成，则跳过
                if (lineStart.QtyRemain == 0)
                {
                    continue;
                }

                if (lineStart.StartTime == DateTime.MinValue)
                {
                    var entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrd.Domain;
                    entity.WorkOrd = workOrd.WorkOrd;
                    entity.ItemNum = workOrd.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-{lineStart.InternalEquipmentCode}工序准备记录的产线错误！";
                    entity.Type = "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                    return;
                }
                if (lineStart.setupTime > 240)
                {
                    var entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrd.Domain;
                    entity.WorkOrd = workOrd.WorkOrd;
                    entity.ItemNum = workOrd.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = $"{workOrd.WorkOrd}排产异常：{workOrdRoutings[i].OP}-{lineStart.InternalEquipmentCode}工序生产准备时长超过10天！";
                    entity.Type = "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                    return;
                }
                //每天所需设备数（向上圆整）
                Maxednum = lineStart.OpType == "P" && remainNum > 0 ? Convert.ToInt32(Math.Ceiling(remainNum / (lineStart.Rate * 24))) : (remainNum <= 0 ? 1 : Convert.ToInt32(Math.Ceiling(remainNum / (lineStart.Rate * 24) / 2)));
                //当前班次可用设备数,无模具取设备数，有模具取模具数
                lineStart.equipmentNum = lineStart.OpType == "P" ? Maxednum : lineStart.equipmentNum;
                //实际使用设备数,Maxednum=0代表所需时长超过剩余时长，直接使用所有设备生产
                lineStart.equipmentNum = Maxednum == 0 ? lineStart.equipmentNum : (lineStart.equipmentNum > Maxednum ? Maxednum : (lineStart.equipmentNum == 0 ? Maxednum : lineStart.equipmentNum));

                //产线排产开始时间
                DateTime workStartTime = lineStart.StartTime;
                //正常工单排产
                //正常工单产线已排产数量
                decimal sumQty = 0m;
                //产线准备时间(分钟)
                decimal sumTimes = 0m;
                //之前的排产记录
                var previouslyOPNum = previouslyOP.Where(s => s.WorkOrd == workOrd.WorkOrd && s.Op == lineStart.Op && s.WorkStartTime < lineStart.StartTime && s.SetupTime > 0).Count();
                while (sumQty < lineStart.QtyRemain)
                {
                    //获取当天的产能
                    LineScheduledDto dto = GetScheduledPoint(lineStart, workStartTime, mLCalendars, mlqtyWorkDtls);
                    //获取当天的工作时间段
                    var curCalendar = mLCalendars.FirstOrDefault(p => !string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == (int)workStartTime.DayOfWeek);
                    if (curCalendar == null)
                    {
                        curCalendar = mLCalendars.FirstOrDefault(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == (int)workStartTime.DayOfWeek);
                    }
                    List<LineWorkPointDto> workPoints = DealWorkDayToLevels(lineStart.Line, workStartTime, curCalendar, mlqtyWorkDtls);
                    //排产开始时，需要先减去产线准备时间(产线提前期满足的当天排产)
                    if (sumTimes < lineStart.setupTime * 60)
                    {
                        //当天的可用生产时长能满足提前期
                        if (dto.EffTime > lineStart.setupTime * 60 - sumTimes)
                        {
                            //当天剩余时长(分钟)=当天可用上产时长-剩余产线准备时间
                            decimal residueTime = dto.EffTime - (lineStart.setupTime * 60 - sumTimes);
                            //产线提前期安排完之后，需要考虑当前是否存在特殊工单：
                            //1、如果当天是排产的最后一天，则先排完正常工单，再安排特殊工单；
                            //2、如果是排产中间日期，则先安排特殊工单排产
                            //当天剩余产能
                            decimal sumAmount = Math.Ceiling(dto.Rate * residueTime / 60);
                            //已排产数量+当天的剩余产能小于工单剩余需排产数量,当天的产能需要全部排产
                            if (sumQty + sumAmount < lineStart.QtyRemain)
                            {
                                //记录生产周期
                                curSequences.Add(new PeriodSequenceDet
                                {
                                    Domain = domain,
                                    Line = lineStart.Line,
                                    ItemNum = workOrd.ItemNum,
                                    PlanDate = workStartTime.Date,
                                    Period = dto.Period,
                                    OrdQty = sumAmount,
                                    WorkOrds = workOrd.WorkOrd,
                                    Op = lineStart.Op,
                                    IsActive = true,
                                    Status = "",
                                    CreateTime = DateTime.Now
                                });
                                //记录排产记录
                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                {
                                    Domain = domain,
                                    WorkOrd = workOrd.WorkOrd,
                                    Line = lineStart.Line,
                                    ItemNum = workOrd.ItemNum,
                                    Op = lineStart.Op,
                                    WorkDate = workStartTime.Date,
                                    WorkQty = sumAmount,
                                    WorkStartTime = dto.StartTime,
                                    WorkEndTime = dto.EndTime,
                                    CreateTime = DateTime.Now
                                });
                                //累计已排产数量
                                sumQty += sumAmount;
                                //继续排下一个工作日
                                workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                            }
                            //当天的剩余产能可满足正常工单剩余待排产数量,则先排正常工单，需要考虑清场时间，如果有特殊工单，则后排
                            else
                            {
                                //剩余需要排产的数量
                                decimal residueQty = lineStart.QtyRemain - sumQty;
                                //剩余数量生产需要时长(分钟)
                                decimal workTime = Math.Ceiling(residueQty / dto.Rate * 60);
                                //处理工作时长:防止相上取整导致时间大于剩余可用时长
                                workTime = workTime >= residueTime ? residueTime : workTime;
                                //排产结束时间
                                DateTime workEndTime = workStartTime;
                                var curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                //开始时间为凌晨时，改为寻找8点开始的工作时间段
                                if (curPoint == null)
                                {
                                    curPoint=workPoints.Find(p => p.StartPoint >= workStartTime && workStartTime <= p.EndPoint);
                                    workStartTime = curPoint.StartPoint;
                                }
                                span = curPoint.EndPoint - workStartTime;
                                //当天工作时间段的有效生产时间
                                decimal effMins = (decimal)span.TotalMinutes;
                                //当前工作时间段即可满足产能
                                if (effMins >= workTime)
                                {
                                    workEndTime = workStartTime.AddMinutes((double)workTime);
                                }
                                else
                                {
                                    //获取后续生产时间段
                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                    //剩余需要工作时长
                                    decimal nextMins = workTime - effMins;
                                    foreach (var p in nextPoints)
                                    {
                                        if (p.WorkMinutes >= nextMins)
                                        {
                                            workEndTime = p.StartPoint.AddMinutes((double)nextMins);
                                            break;
                                        }
                                        nextMins -= p.WorkMinutes;
                                    }
                                }
                                //工单排产完成，已排产数量=工单需排产数量数量
                                sumQty = lineStart.QtyRemain;
                                //当天剩余可用生产时长
                                residueTime -= workTime;
                                //处理清场时间，两种场景：
                                //1、residueTime<=lineStart.WaitTime,结束时间加上剩余清场时长
                                if (residueTime <= lineStart.WaitTime)
                                {
                                    //仍需排产的清场时长
                                    decimal otherTime = lineStart.WaitTime - residueTime;
                                    workEndTime = dto.EndTime.AddMinutes((double)otherTime);
                                    residueTime = 0;
                                }
                                //2、residueTime>lineStart.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                else
                                {
                                    //清场时长
                                    workTime = lineStart.WaitTime;
                                    //获取工单排产结束时间所处时间段
                                    curPoint = workPoints.Find(p => p.StartPoint <= workEndTime && workEndTime <= p.EndPoint);
                                    span = curPoint.EndPoint - workEndTime;
                                    //当前工作时间段的有效生产时间(分钟)
                                    effMins = (decimal)span.TotalMinutes;
                                    //当前工作时间段即可清场时长
                                    if (effMins >= workTime)
                                    {
                                        workEndTime = workEndTime.AddMinutes((double)workTime);
                                    }
                                    else
                                    {
                                        //获取后续生产时间段
                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                        //剩余需要工作时长
                                        decimal nextMins = workTime - effMins;
                                        foreach (var p in nextPoints)
                                        {
                                            if (p.WorkMinutes >= nextMins)
                                            {
                                                workEndTime = p.StartPoint.AddMinutes((double)nextMins);
                                                break;
                                            }
                                            nextMins -= p.WorkMinutes;
                                        }
                                    }
                                    residueTime -= workTime;
                                }
                                
                                //记录生产周期
                                curSequences.Add(new PeriodSequenceDet
                                {
                                    Domain = domain,
                                    Line = lineStart.Line,
                                    ItemNum = workOrd.ItemNum,
                                    PlanDate = workStartTime.Date,
                                    Period = dto.Period,
                                    OrdQty = residueQty,
                                    WorkOrds = workOrd.WorkOrd,
                                    Op = lineStart.Op,
                                    IsActive = true,
                                    Status = "",
                                    CreateTime = DateTime.Now
                                });
                                //记录排产记录
                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                {
                                    Domain = domain,
                                    WorkOrd = workOrd.WorkOrd,
                                    Line = lineStart.Line,
                                    ItemNum = workOrd.ItemNum,
                                    Op = lineStart.Op,
                                    WorkDate = workStartTime.Date,
                                    WorkQty = residueQty,
                                    WorkStartTime = workStartTime,
                                    WorkEndTime = workEndTime,
                                    CreateTime = DateTime.Now
                                });
                            }
                            //记录提前期
                            sumTimes = lineStart.setupTime * 60;
                        }
                        //当天可用生产时长不能满足或者刚好满足提前期
                        else
                        {
                            //当天的可用生产时长不能满足提前期
                            sumTimes += dto.EffTime;
                            //获取下一个工作日
                            workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                        }
                    }
                    //产线提前期满足的下一个工作日排产
                    else
                    {
                        //已排产数量+当天的产能小于工单数量，当天的产能需要全部排产
                        if (sumQty + dto.ProductQty < lineStart.QtyRemain)
                        {
                            //记录生产周期
                            curSequences.Add(new PeriodSequenceDet
                            {
                                Domain = domain,
                                Line = lineStart.Line,
                                ItemNum = workOrd.ItemNum,
                                PlanDate = workStartTime.Date,
                                Period = dto.Period,
                                OrdQty = dto.ProductQty,
                                WorkOrds = workOrd.WorkOrd,
                                Op = lineStart.Op,
                                IsActive = true,
                                Status = "",
                                CreateTime = DateTime.Now
                            });
                            //记录排产记录
                            curScheduleRsts.Add(new ScheduleResultOpMaster
                            {
                                Domain = domain,
                                WorkOrd = workOrd.WorkOrd,
                                Line = lineStart.Line,
                                ItemNum = workOrd.ItemNum,
                                Op = lineStart.Op,
                                WorkDate = workStartTime.Date,
                                WorkQty = dto.ProductQty,
                                WorkStartTime = dto.StartTime,
                                WorkEndTime = dto.EndTime,
                                CreateTime = DateTime.Now
                            });
                            //累计已排产数量
                            sumQty += dto.ProductQty;
                            //继续排下一个工作日
                            workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                        }
                        //剩余产能满足正常工单待排产数量，此时需要排清场时长
                        else
                        {
                            //当天可用生产时长
                            decimal residueTime = dto.EffTime;
                            //正常工单生产时长
                            decimal workTime = 0m;
                            DateTime workEndTime = workStartTime;
                            if (sumQty < lineStart.QtyRemain)
                            {
                                //剩余需要排产的数量
                                decimal residueQty = lineStart.QtyRemain - sumQty;
                                //剩余数量生产需要时长(分钟)
                                workTime = Math.Ceiling(residueQty / dto.Rate * 60);
                                //处理需要生产时长
                                workTime = workTime >= residueTime ? residueTime : workTime;
                                var curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                //开始时间为凌晨时，改为寻找8点开始的工作时间段
                                if (curPoint == null)
                                {
                                    curPoint = workPoints.Find(p => p.StartPoint >= workStartTime && workStartTime <= p.EndPoint);
                                    workStartTime = curPoint.StartPoint;
                                }
                                span = curPoint.EndPoint - workStartTime;
                                //当天工作时间段的有效生产时间
                                decimal effMins = (decimal)span.TotalMinutes;
                                //当前工作时间段即可满足产能
                                if (effMins >= workTime)
                                {
                                    workEndTime = workStartTime.AddMinutes((double)workTime);
                                }
                                else
                                {
                                    //获取后续生产时间段
                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                    //剩余需要工作时长
                                    decimal nextMins = workTime - effMins;
                                    foreach (var p in nextPoints)
                                    {
                                        if (p.WorkMinutes >= nextMins)
                                        {
                                            workEndTime = p.StartPoint.AddMinutes((double)nextMins);
                                            break;
                                        }
                                        nextMins -= p.WorkMinutes;
                                    }
                                }
                                //工单排产完成，已排产数量=工单数量
                                sumQty = lineStart.QtyRemain;
                                //剩余可用生产时长
                                residueTime = (residueTime - workTime) < 0 ? 0 : (residueTime - workTime);
                                //处理清场时间，两种场景：
                                //1、residueTime<=lineStart.WaitTime,结束时间加上剩余清场时长
                                if (residueTime <= lineStart.WaitTime)
                                {
                                    //仍需排产的清场时长
                                    decimal otherTime = lineStart.WaitTime - residueTime;
                                    workEndTime = dto.EndTime.AddMinutes((double)otherTime);
                                    residueTime = 0;
                                }
                                //2、residueTime>lineStart.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                else
                                {
                                    //清场时长
                                    workTime = lineStart.WaitTime;
                                    //获取工单排产结束时间所处时间段
                                    curPoint = workPoints.Find(p => p.StartPoint <= workEndTime && workEndTime <= p.EndPoint);
                                    span = curPoint.EndPoint - workEndTime;
                                    //当前工作时间段的有效生产时间(分钟)
                                    effMins = (decimal)span.TotalMinutes;
                                    //当前工作时间段即可清场时长
                                    if (effMins >= workTime)
                                    {
                                        workEndTime = workEndTime.AddMinutes((double)workTime);
                                    }
                                    else
                                    {
                                        //获取后续生产时间段
                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                        //剩余需要工作时长
                                        decimal nextMins = workTime - effMins;
                                        foreach (var p in nextPoints)
                                        {
                                            if (p.WorkMinutes >= nextMins)
                                            {
                                                workEndTime = p.StartPoint.AddMinutes((double)nextMins);
                                                break;
                                            }
                                            nextMins -= p.WorkMinutes;
                                        }
                                    }
                                    //剩余生产时长
                                    residueTime -= workTime;
                                }
                                //记录生产周期
                                curSequences.Add(new PeriodSequenceDet
                                {
                                    Domain = domain,
                                    Line = lineStart.Line,
                                    ItemNum = workOrd.ItemNum,
                                    PlanDate = workStartTime.Date,
                                    Period = dto.Period,
                                    OrdQty = residueQty,
                                    WorkOrds = workOrd.WorkOrd,
                                    Op = lineStart.Op,
                                    IsActive = true,
                                    Status = "",
                                    CreateTime = DateTime.Now
                                });
                                //记录排产记录
                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                {
                                    Domain = domain,
                                    WorkOrd = workOrd.WorkOrd,
                                    Line = lineStart.Line,
                                    ItemNum = workOrd.ItemNum,
                                    Op = lineStart.Op,
                                    WorkDate = workStartTime.Date,
                                    WorkQty = residueQty,
                                    WorkStartTime = workStartTime,
                                    WorkEndTime = workEndTime,
                                    CreateTime = DateTime.Now
                                });

                                //处理排产开始时间
                                workStartTime = workEndTime;
                                curPoint = workPoints.FirstOrDefault(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                if (curPoint != null && workStartTime == curPoint.EndPoint)
                                {
                                    var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                    workStartTime = nextPoint == null ? workStartTime : nextPoint.StartPoint;
                                }
                            }
                        }
                    }
                }
            }
            //记录排产结果
            periodsDet.AddRange(curSequences);
            scheduleResults.AddRange(curScheduleRsts);
        }

        /// <summary>
        /// 计算当天排产完成的剩余生产时长
        /// </summary>
        /// <param name="endTime">排产结束时间</param>
        /// <param name="workPoints">当天的工作时间段</param>
        /// <returns></returns>
        public decimal CalcRemainWorkTime(DateTime endTime, List<LineWorkPointDto> workPoints)
        {
            decimal remainTime = 0m;
            var curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
            TimeSpan span = curPoint.EndPoint - endTime;
            remainTime = (decimal)span.TotalMinutes;
            var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
            foreach (var item in nextPoints)
            {
                remainTime += item.WorkMinutes;
            }
            return remainTime;
        }

        /// <summary>
        /// 获取产线当天的开工时间，结束时间，有效工作时长,生产数量
        /// </summary>
        /// <param name="lineStart">排产产线</param>
        /// <param name="startTime">产线排产开始时间</param>
        /// <param name="curCalendars"></param>
        /// <param name="curQtyDtls"></param>
        /// <returns></returns>
        public LineScheduledDto GetScheduledPoint(LineStartDto lineStart, DateTime startTime, List<ShopCalendarWorkCtr> curCalendars, List<QualityLineWorkDetail> curQtyDtls)
        {
            LineScheduledDto scheduledDto = new LineScheduledDto();
            //当天排产开始时间
            scheduledDto.StartTime = startTime;
            //开始时间是周几
            int weekDay = (int)startTime.DayOfWeek;
            //当天的工作日历
            var shopCal = curCalendars.Where(p => !string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == weekDay).FirstOrDefault();
            if (shopCal == null)//当前产线当天没有设置工作日历
            {
                //取默认工作日历
                shopCal = curCalendars.Where(p =>string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == weekDay).FirstOrDefault();
            }
            //当前日期的工作时间段
            List<LineWorkPointDto> workPoints = DealWorkDayToLevels(lineStart.Line, startTime, shopCal, curQtyDtls);
            //当天排产结束时间
            scheduledDto.EndTime = workPoints.Last().EndPoint;
            //计算starttime处于那个工作时间段
            var curPoint = workPoints.Where(p => startTime >= p.StartPoint && startTime <= p.EndPoint).FirstOrDefault();
            //开始时间不在工作时间段
            if (curPoint == null)
            {
                //获取离开始时间最近的时间段
                curPoint = workPoints.Where(p => p.EndPoint < startTime).OrderBy(p => p.Level).LastOrDefault();
                if (curPoint == null)
                {
                    curPoint = workPoints.Where(p => startTime < p.StartPoint).OrderBy(p => p.Level).FirstOrDefault();
                }
                startTime = curPoint.EndPoint;
            }
            TimeSpan span = curPoint.EndPoint - startTime;
            scheduledDto.EffTime = (decimal)span.TotalMinutes;
            //获取后续工作时间段的有效工作时间
            var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
            foreach (var item in nextPoints)
            {
                span = item.EndPoint - item.StartPoint;
                scheduledDto.EffTime += (decimal)span.TotalMinutes;
            }
            //判断当前产线的UPH
            var curRunCrews = prodLineDetailRunCrews.Where(p=>p.ProdLineDetailRecID == lineStart.RecID).ToList();
            //判断当前日期是否配置了UPH
            var curLevel = curRunCrews.FirstOrDefault(p => p.StartDate.GetValueOrDefault().Date <= startTime.Date && p.EndDate.GetValueOrDefault().Date >= startTime.Date);
            decimal rate = curLevel == null ? lineStart.Rate : curLevel.Rate;
            scheduledDto.Rate = rate;
            //产线当天加班设置
            var curOccupyTimes = resourceOccupancyTimes.Where(p => p.Resource == lineStart.Line && p.StartTime.GetValueOrDefault().Date == startTime.Date).OrderBy(p => p.StartTime).ToList();
            scheduledDto.EffTime += curOccupyTimes.Sum(p=> Convert.ToDecimal(p.Ufld1) * 60);
            if (curOccupyTimes.Any())
            {
                var last = curOccupyTimes.Last();
                scheduledDto.EndTime = last.StartTime.GetValueOrDefault().AddHours(Convert.ToDouble(last.Ufld1));
            }
            //计算当天的产能(向上取整)
            scheduledDto.ProductQty = Math.Ceiling(scheduledDto.EffTime / 60 * rate);
            //计算班次
            scheduledDto.Period = 1;//默认一班制
            if (shopCal.ShiftsStart2 != 0 && shopCal.ShiftsHours2 != 0)
            {
                scheduledDto.Period = 2;
            }
            return scheduledDto;
        }

        /// <summary>
        /// 计算主产线实际排产开始时间
        /// </summary>
        /// <param name="workOrd">工单</param>
        /// <param name="routing">工序</param>
        /// <param name="prodLines">生产线明细</param>
        /// <param name="allResults">产线占用记录</param>
        /// <returns></returns>
        public LineStartDto DealStartTime(WorkOrdMaster workOrd,WorkOrdRouting routing,List<ProdLineDetail> prodLines, List<ScheduleResultOpMaster> allResults, List<ScheduleExceptionMaster> exceptions, List<ShopCalendarWorkCtr> curCalendars, List<QualityLineWorkDetail> curQtyDtls, bool Check = false, bool UseSkill = true)
        {
            LineStartDto lineStart = new LineStartDto();
            //排产工序
            int op = routing.OP;
            //排产任务执行时间
            DateTime actStart = scheTime;

            lineStart.WorkCtr = !string.IsNullOrEmpty(routing.WorkCtr) ? routing.WorkCtr : (prodLines.Count > 0 ? (prodLines[0].Site != routing.WorkCtr && !string.IsNullOrEmpty(routing.WorkCtr) ? routing.WorkCtr : prodLines[0].Site) : routing.WorkCtr);
            lineStart.SkillNo = !string.IsNullOrEmpty(routing.Engineer) ? routing.Engineer : (prodLines.Count > 0 ? prodLines[0].SkillNo : routing.Engineer);
            lineStart.StandardStaffCount = routing.RunCrew > 0 ? routing.RunCrew : (prodLines.Count > 0 ? prodLines[0].StandardStaffCount : routing.RunCrew);
            lineStart.OpType = !string.IsNullOrEmpty(routing.WorkCode) ? routing.WorkCode : (prodLines.Count > 0 ? prodLines[0].OpType : routing.WorkCode);
            lineStart.Op = routing.OP;
            lineStart.InternalEquipmentCode = lineStart.OpType == "P" ? "" : (!string.IsNullOrEmpty(routing.Machine) ? routing.Machine : (prodLines.Count > 0 ? prodLines[0].InternalEquipmentCode : routing.Machine));
            lineStart.MoldTypeCode = lineStart.OpType == "P" ? "" : (!string.IsNullOrEmpty(routing.ToolCode) ? routing.ToolCode : (prodLines.Count > 0 ? prodLines[0].MoldTypeCode : routing.ToolCode));
            lineStart.RecID = prodLines.Count > 0 ? prodLines[0].RecID : 0;
            lineStart.Line = !string.IsNullOrEmpty(routing.ProdLine) ? routing.ProdLine : (prodLines.Count > 0 ? (prodLines[0].Line != routing.ProdLine && !string.IsNullOrEmpty(routing.ProdLine) ? routing.ProdLine : prodLines[0].Line) : routing.ProdLine);
            lineStart.setupTime = routing.StdSetupTime > 0 ? routing.StdSetupTime : (prodLines.Count > 0 ? prodLines[0].SetupTime : routing.StdSetupTime);
            lineStart.Rate = routing.MachBdnRate > 0 ? routing.MachBdnRate : (prodLines.Count > 0 ? prodLines[0].Rate : routing.MachBdnRate);
            lineStart.OldRate = routing.MachBdnRate > 0 ? routing.MachBdnRate : (prodLines.Count > 0 ? prodLines[0].Rate : routing.MachBdnRate);

            if (!string.IsNullOrEmpty(workOrd.JointTyped) && workOrd.JointTyped.ToUpper() == "B")
            {
                actStart = workOrd.OrdDate.GetValueOrDefault();
            }
            //获取工序对应的产线,根据优先级排序
            var lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == op).OrderBy(p => p.Sequence).ToList();
            //获取工序开始准备时长记录
            var curRecord = timeRecords.FirstOrDefault(p => p.Domain == domain && p.WorkOrd == workOrd.WorkOrd && p.Op == op);
            //如果产线有准备时间记录且准备开始时间在当前时间之前，说明已在排产中，此时不需要重新获取产线
            if (curRecord != null && curRecord.StartTime < actStart)
            {
                var curLine = lines.FirstOrDefault(p=>p.Line == curRecord.Line);
                if (curLine != null)
                {
                    //计算产线实际开始时间
                    //产线工作日历:当前产线的工作日历 + 默认工作日历
                    //var curCalendars = calendars.Where(p => p.ProdLine == curLine.Line || string.IsNullOrEmpty(p.ProdLine)).ToList();
                    //var curQtyDtls = qualityLines.Where(p => p.ProdLine == curLine.Line).ToList();
                    actStart = CalcActStartTime(curLine.Line, actStart, curCalendars, curQtyDtls);
                    lineStart.RecID = curLine.RecID;
                    lineStart.Line = curLine.Line;
                    lineStart.StartTime = actStart;
                    lineStart.setupTime = curLine.SetupTime;
                    lineStart.Rate = curLine.Rate;
                }
            }
            else {
                //获取第一条产线排产结束时间
                var schedule = allResults.Where(p => p.Line == lines[0].Line).OrderByDescending(p => p.WorkEndTime).FirstOrDefault();
                actStart = schedule == null ? actStart : (schedule.WorkEndTime >= actStart ? schedule.WorkEndTime : actStart);
                //计算实际开工时间
                //产线工作日历:当前产线的工作日历+默认工作日历
                //var curCalendars = calendars.Where(p => p.ProdLine == lines[0].Line || string.IsNullOrEmpty(p.ProdLine)).ToList();
                //var curQtyDtls = qualityLines.Where(p => p.ProdLine == lines[0].Line).ToList();
                actStart = CalcActStartTime(lines[0].Line, actStart, curCalendars, curQtyDtls);
                lineStart.RecID = lines[0].RecID;
                lineStart.Line = lines[0].Line;
                lineStart.StartTime = actStart;
                lineStart.setupTime = lines[0].SetupTime;
                lineStart.Rate = lines[0].Rate;
                //循环其他产线
                for (int i = 1; i < lines.Count; i++)
                {
                    schedule = allResults.Where(p => p.Line == lines[i].Line).OrderByDescending(p => p.WorkEndTime).FirstOrDefault();
                    DateTime StartTime = schedule == null ? actStart : (schedule.WorkEndTime >= actStart ? schedule.WorkEndTime : actStart);
                    //计算实际开工时间
                    //产线工作日历:当前产线的工作日历+默认工作日历
                    curCalendars = calendars.Where(p => p.ProdLine == lines[i].Line || string.IsNullOrEmpty(p.ProdLine)).ToList();
                    curQtyDtls = qualityLines.Where(p => p.ProdLine == lines[i].Line).ToList();
                    StartTime = CalcActStartTime(lines[0].Line, StartTime, curCalendars, curQtyDtls);
                    if (StartTime < lineStart.StartTime)
                    {
                        lineStart.RecID = lines[i].RecID;
                        lineStart.Line = lines[i].Line;
                        lineStart.StartTime = StartTime;
                        lineStart.setupTime = lines[i].SetupTime;
                        lineStart.Rate = lines[i].Rate;
                    }
                }
                //当前工序没有开始准备时间记录
                if (curRecord == null)
                {
                    //添加记录
                    inserts.Add(new WorkOrdSetupTimeRecord
                    {
                        Domain = workOrd.Domain,
                        WorkOrd = workOrd.WorkOrd,
                        ItemNum = workOrd.ItemNum,
                        Op = op,
                        Line = lineStart.Line,
                        StartTime = lineStart.StartTime,
                        CreateTime = DateTime.Now
                    });
                    //记录工序开始准备时间记录
                    timeRecords.Add(new WorkOrdSetupTimeRecord
                    {
                        Domain = workOrd.Domain,
                        WorkOrd = workOrd.WorkOrd,
                        ItemNum = workOrd.ItemNum,
                        Op = op,
                        Line = lineStart.Line,
                        StartTime = lineStart.StartTime,
                        CreateTime = DateTime.Now
                    });
                }
                else {
                    //更新准备开始时间记录
                    timeRecords.ForEach(p => {
                        p.Line = p.WorkOrd == workOrd.WorkOrd && p.Op == curRecord.Op ? lineStart.Line : p.Line;
                        p.StartTime = p.WorkOrd == workOrd.WorkOrd && p.Op == curRecord.Op ? lineStart.StartTime : p.StartTime;
                    });
                    //存在开始准备时间记录，则更新
                    curRecord.Line = lineStart.Line;
                    curRecord.StartTime = lineStart.StartTime;
                    updates.Add(curRecord);
                }
            }
            //计算准备开始时间点与当前时间点的有效时长
            decimal sumTimes = 0m;
            if (curRecord != null)
            {
                sumTimes = CalcTimeMins(curRecord.StartTime, lineStart.StartTime, lineStart.Line);
                //如果当前工单状态为生产中"W",但是，调整了日计划开工时间，则需要重新准备
                if (workOrd.Status.ToUpper() == "W" && !string.IsNullOrEmpty(workOrd.JointTyped) &&  workOrd.JointTyped.ToUpper() == "B")
                {
                    sumTimes = 0m;
                }
            }
            //产线准备完成之后到当前时间点剩余时长(小时)
            decimal restTime = lineStart.setupTime - sumTimes / 60;
            lineStart.setupTime = restTime <= 0 ? 0 : restTime;
            lineStart.Op = op;
            lineStart.WaitTime = routing.WaitTime * 60;

            //判断当前产线的UPH
            var curRunCrews = prodLineDetailRunCrews.Where(p => p.ProdLineDetailRecID == lineStart.RecID).ToList();
            //判断当前日期是否配置了UPH
            var curLevel = curRunCrews.FirstOrDefault(p => p.StartDate.GetValueOrDefault().Date <= lineStart.StartTime.Date && p.EndDate.GetValueOrDefault().Date >= lineStart.StartTime.Date);
            //当天的实际UPH
            decimal rate = curLevel == null ? lineStart.Rate : curLevel.Rate;

            //计算上次报工到当前时间点的预估生产数量，如果没有报工记录，则计算产线准备时间完成到当前时间点的预估生产数量
            decimal planQty = 0m;
            if (routing.Last == null && restTime < 0 && workOrd.Status.ToUpper() == "W")
            {
                //工序没有报工，使用产线准备完成之后到当前时间点剩余时长计算预估生产数量
                planQty = Math.Floor(Math.Abs(restTime) * rate);
            }
            else if(routing.Last != null)
            {
                //工序存在报工记录，计算报工时间点到当前时间点的有效生产时长，然后计算预估生产数量
                sumTimes = CalcTimeMins(routing.Last.GetValueOrDefault(), lineStart.StartTime, lineStart.Line);
                planQty = Math.Floor(sumTimes / 60 * rate);
            }
            //剩余待排产数量=工单数量-已报工数量-预估数量
            decimal restQty = workOrd.QtyOrded - routing.QtyComplete - planQty;
            lineStart.QtyRemain = restQty < 0 ? (workOrd.QtyOrded - routing.QtyComplete) : restQty;
            return lineStart;
        }

        /// <summary>
        /// 计算两个时间点之间的有效时长
        /// </summary>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="line">产线</param>
        /// <returns></returns>
        public decimal CalcTimeMins(DateTime startTime, DateTime endTime, string line)
        {
            decimal sumTimes = 0m;
            //如果开始时间大于结束时间直接返回0
            if (endTime <= startTime)
            {
                return sumTimes;
            }

            TimeSpan span = TimeSpan.Zero;
            //产线休息时间段设置
            var curQtyDtls = qualityLines.Where(p => p.ProdLine == line).ToList();
            //获取产线在开始时间当天的工作时间段
            var curCalendar = calendars.FirstOrDefault(p => p.ProdLine == line && p.WeekDay == (int)startTime.DayOfWeek);
            if (curCalendar == null)
            {
                curCalendar = calendars.FirstOrDefault(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == (int)startTime.DayOfWeek);
            }
            List<LineWorkPointDto> workPoints = DealWorkDayToLevels(line, startTime, curCalendar, curQtyDtls);
            //开始时间所处时间段
            var srtPoint = workPoints.FirstOrDefault(p => p.StartPoint <= startTime && startTime <= p.EndPoint);
            if (srtPoint == null)
            {
                //获取开始时间最近的时间段
                //开始时间小于工作开始时间
                if (startTime <= workPoints[0].StartPoint)
                {
                    srtPoint = workPoints[0];
                    startTime = srtPoint.StartPoint;
                }
                else {
                    srtPoint = workPoints.Where(p => p.EndPoint <= startTime).OrderBy(p => p.Level).Last();
                    startTime = srtPoint.EndPoint;
                }
            }
            //开始时间、结束时间处于同一天
            if (startTime.Date == endTime.Date)
            {
                //结束时间所处时间段
                var lstPoint = workPoints.FirstOrDefault(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                //结束时间位于休息时间段
                if (lstPoint == null)
                {
                    //获取结束时间最近的时间段
                    //lstPoint = workPoints.Where(p => p.EndPoint <= endTime).OrderBy(p => p.Level).Last();
                    //endTime = lstPoint.EndPoint;
                    //获取开始时间最近的时间段
                    //结束时间小于工作开始时间
                    if (endTime <= workPoints[0].StartPoint)
                    {
                        lstPoint = workPoints[0];
                        endTime = lstPoint.StartPoint;
                    }
                    else
                    {
                        lstPoint = workPoints.Where(p => p.EndPoint <= endTime).OrderBy(p => p.Level).Last();
                        endTime = lstPoint.EndPoint;
                    }
                }
                //开始时间和结束时间位于同一时间段
                if (srtPoint.Level == lstPoint.Level)
                {
                    span = endTime - startTime;
                    sumTimes = (decimal)span.TotalMinutes;
                    return sumTimes;
                }
                //开始时间，结束时间位于不同时间段
                //计算开始时间所处时间段的有效时长
                span = srtPoint.EndPoint - startTime;
                sumTimes += (decimal)span.TotalMinutes;
                //计算结束时间所处时间段的有效时长
                span = endTime - lstPoint.StartPoint;
                sumTimes += (decimal)span.TotalMinutes;
                //计算开始时间，结束时间中间的工作时长
                var others = workPoints.Where(p => p.Level > srtPoint.Level && p.Level < lstPoint.Level).ToList();
                sumTimes += others.Sum(p => p.WorkMinutes);
                return sumTimes;
            }
            //开始时间、结束时间不处于同一天
            //1、计算开始时间所在当天剩余有效工作时长
            span = srtPoint.EndPoint - startTime;
            sumTimes += (decimal)span.TotalMinutes;
            var nextPoints = workPoints.Where(p => p.Level > srtPoint.Level);
            sumTimes += nextPoints.Sum(p => p.WorkMinutes);
            //2、计算结束时间所在当天有效工作时长
            curCalendar = calendars.FirstOrDefault(p => p.ProdLine == line && p.WeekDay == (int)endTime.DayOfWeek);
            if (curCalendar == null)
            {
                curCalendar = calendars.FirstOrDefault(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == (int)endTime.DayOfWeek);
            }
            workPoints = DealWorkDayToLevels(line, endTime, curCalendar, curQtyDtls);
            var curPoint = workPoints.FirstOrDefault(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
            if (curPoint == null)
            {
                //获取结束时间最近的时间段
                //curPoint = workPoints.Where(p => p.EndPoint <= endTime).OrderBy(p => p.Level).Last();
                //endTime = curPoint.EndPoint;
                //结束时间小于工作开始时间
                if (endTime <= workPoints[0].StartPoint)
                {
                    curPoint = workPoints[0];
                    endTime = curPoint.StartPoint;
                }
                else
                {
                    curPoint = workPoints.Where(p => p.EndPoint <= endTime).OrderBy(p => p.Level).Last();
                    endTime = curPoint.EndPoint;
                }
            }
            span = endTime - curPoint.StartPoint;
            sumTimes += (decimal)span.TotalMinutes;
            nextPoints = workPoints.Where(p => p.Level < curPoint.Level);
            sumTimes += nextPoints.Sum(p => p.WorkMinutes);
            //3、计算中间天数的有效工作时长
            span = endTime.Date - startTime.Date;
            int days = span.Days;
            for (int i = 1; i < days; i++)
            {
                var newDate = startTime.Date.AddDays(i);
                //获取产线的工作时间段
                curCalendar = calendars.FirstOrDefault(p => p.ProdLine == line && p.WeekDay == (int)newDate.DayOfWeek);
                if (curCalendar == null)
                {
                    curCalendar = calendars.FirstOrDefault(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == (int)newDate.DayOfWeek);
                }
                workPoints = DealWorkDayToLevels(line, newDate, curCalendar, curQtyDtls);
                //当天的有效工作时长
                sumTimes += workPoints.Sum(p => p.WorkMinutes);
            }
            return sumTimes;
        }

        /// <summary>
        /// 计算主产线实际排产开始时间
        /// </summary>
        /// <param name="prodLine">生产线</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="curCalendars">当前产线工作日历+默认工作日历</param>
        /// <param name="curQtyDtls">当前产线休息记录</param>
        /// <returns></returns>
        public DateTime CalcActStartTime(string prodLine,DateTime startTime, List<ShopCalendarWorkCtr> curCalendars, List<QualityLineWorkDetail> curQtyDtls)
        {
            //实际排产开始时间
            DateTime actStart = startTime;
            //开始时间是周几
            int weekDay = (int)startTime.DayOfWeek;
            //判断当天是否是工作日
            bool isWorkDay = CheckIsWorkDay(startTime);
            if (!isWorkDay)//不是工作日
            {
                //获取下一个工作日开始时间
                actStart = GetNextWorkDay(weekDay, startTime, curCalendars);
                return actStart;
            }

            //当天的工作日历
            var shopCal = curCalendars.Where(p => !string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == weekDay).FirstOrDefault();
            if (shopCal == null)
            {
                //产线没有维护当天的工作日历，则取默认工作日历
                shopCal = curCalendars.Where(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == weekDay).FirstOrDefault();
            }
            //当前日期的工作时间段
            List<LineWorkPointDto> workPoints = DealWorkDayToLevels(prodLine, startTime, shopCal, curQtyDtls);
            //计算starttime处于那个工作时间段
            var curPoint = workPoints.Where(p => startTime >= p.StartPoint && startTime <= p.EndPoint).FirstOrDefault();
            if (curPoint == null)//不处于工作时间段
            {
                //开始时间小于当天工作开始时间
                if (startTime < workPoints.First().StartPoint)
                {
                    actStart = workPoints.First().StartPoint;
                }
                //开始时间大于当前工作结束时间
                else if (startTime > workPoints.Last().EndPoint)
                {
                    //获取下一个工作日开始时间
                    actStart = GetNextWorkDay(weekDay, startTime, curCalendars);
                }
                else
                {//开始时间位于当天的休息时间段
                    foreach (var item in workPoints)
                    {
                        //获取下一个时间段
                        var next = workPoints.Find(p => p.Level == item.Level + 1);
                        if (item.EndPoint < startTime && startTime < next.StartPoint)
                        {
                            actStart = next.StartPoint;
                            break;
                        }
                    }
                }
                return actStart;
            }
            if (startTime != curPoint.EndPoint)
            {
                return actStart;
            }
            //查询下一时间段的开始时间点
            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="startTime"></param>
        /// <returns></returns>
        public DateTime CalcStartTimeAfter(DateTime startTime)
        {
            DateTime rtnTime = startTime;
            DateTime curDate = startTime.Date;
            //时间转换为分钟
            TimeSpan span = rtnTime - curDate;
            decimal sumMinutes = (decimal)span.TotalMinutes;
            int times = (int)Math.Ceiling(sumMinutes / 30);
            rtnTime = curDate.AddMinutes(times * 30);
            return rtnTime;
        }

        /// <summary>
        /// 排产开始时间处理为半小时/整点开始--向前取整
        /// </summary>
        /// <param name="startTime"></param>
        /// <returns></returns>
        public DateTime CalcStartTimeBefore(DateTime startTime)
        {
            DateTime rtnTime = startTime;
            DateTime curDate = startTime.Date;
            //时间转换为分钟
            TimeSpan span = rtnTime - curDate;
            decimal sumMinutes = (decimal)span.TotalMinutes;
            int times = (int)Math.Floor(sumMinutes / 30);
            rtnTime = curDate.AddMinutes(times * 30);
            return rtnTime;
        }

        /// <summary>
        /// 判断当天是否是工作日
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public bool CheckIsWorkDay(DateTime dateTime)
        {
            bool isWorkDay = true;
            //周几
            int weekDay = (int)dateTime.DayOfWeek;
            //判断当天是否是工作日
            if (weekDay == 0 || weekDay == 6)//周六或者周日，需要判断是否调班，需要加班
            {
                if (!holidays.Exists(p => p.Dated.GetValueOrDefault().Date == dateTime.Date && p.Ufld1 == "调班"))//不是调班
                {
                    isWorkDay = false;
                }
                return isWorkDay;
            }
            //不是周六周日，需要判断是不是节假日
            if (holidays.Exists(p => p.Dated.GetValueOrDefault().Date == dateTime.Date && p.Ufld1 == "休假"))//是节假日
            {
                isWorkDay = false;
            }
            return isWorkDay;
        }

        /// <summary>
        /// 计算下一产线实际排产开始时间
        /// </summary>
        /// <param name="workOrd">工单</param>
        /// <param name="lineStart">上一产线开始时间</param>
        /// <param name="routing">工序</param>
        /// <param name="prodLines">产线明细</param>
        /// <param name="allResults">产线占用记录</param>
        /// <returns></returns>
        public LineStartDto DealNextStartTime(WorkOrdMaster workOrd,LineStartDto lineStart,WorkOrdRouting routing, List<ProdLineDetail> prodLines, List<ScheduleResultOpMaster> allResults, List<ShopCalendarWorkCtr> calendars, List<ScheduleExceptionMaster> exceptions, List<ShopCalendarWorkCtr> curCalendars, List<QualityLineWorkDetail> curQtyDtls, bool Check = false, bool UseSkill = true)
        {
            //本序工序编码
            int op = routing.OP;
            //获取上序实际开工时间
            DateTime preStartTime = lineStart.StartTime;
            //上序的开始准备时间记录
            var preRecord = timeRecords.FirstOrDefault(p=>p.WorkOrd == workOrd.WorkOrd && p.Domain == domain && p.Op == lineStart.Op);
            if (preRecord != null)
            {
                preStartTime = preRecord.StartTime;
            }
            LineStartDto startDto = new LineStartDto();
            //获取产线
            var lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == op).OrderBy(p=>p.Sequence).ToList();
            //当前工序的开始准备时间记录
            var curRecord = timeRecords.FirstOrDefault(p=>p.Domain == domain && p.WorkOrd == workOrd.WorkOrd && p.Op == op);
            //如果产线有准备时间记录且准备开始时间在当前时间之前，说明已在排产中，此时不需要重新获取产线
            if (curRecord != null && curRecord.StartTime < scheTime)
            {
                var curLine = lines.FirstOrDefault(p => p.Line == curRecord.Line);
                if (curLine != null) {
                    //产线工作日历:当前产线的工作日历 + 默认工作日历
                    //var curCalendars = calendars.Where(p => p.ProdLine == curLine.Line || string.IsNullOrEmpty(p.ProdLine)).ToList();
                    //var curQtyDtls = qualityLines.Where(p => p.ProdLine == curLine.Line).ToList();
                    DateTime startTime = CalcActStartTime(curLine.Line, scheTime, curCalendars, curQtyDtls);
                    startDto.RecID = curLine.RecID;
                    startDto.Line = curLine.Line;
                    startDto.StartTime = startTime;
                    startDto.setupTime = curLine.SetupTime;
                    startDto.Rate = curLine.Rate;
                }
            }
            else {
                //获取第一条产线排产结束时间
                var schedule = allResults.Where(p => p.Line == lines[0].Line).OrderByDescending(p => p.WorkEndTime).FirstOrDefault();
                DateTime startTime = CalcStartTimeWithSetUpTime(lines[0], preStartTime, lineStart.setupTime + lines[0].OverlapTime);
                startDto.RecID = lines[0].RecID;
                startDto.Line = lines[0].Line;
                startDto.setupTime = lines[0].SetupTime;
                startDto.StartTime = schedule == null ? startTime : (startTime < schedule.WorkEndTime ? schedule.WorkEndTime : startTime);
                startDto.Rate = lines[0].Rate;
                //循环剩余产线，找到最早可开工产线
                for (int i = 1; i < lines.Count(); i++)
                {
                    schedule = allResults.Where(p => p.Line == lines[i].Line).OrderByDescending(p => p.WorkEndTime).FirstOrDefault();
                    startTime = CalcStartTimeWithSetUpTime(lines[i], preStartTime, lineStart.setupTime + lines[i].OverlapTime);
                    startTime = schedule == null ? startTime : (startTime < schedule.WorkEndTime ? schedule.WorkEndTime : startTime);
                    if (startTime < startDto.StartTime)
                    {
                        startDto.RecID = lines[i].RecID;
                        startDto.Line = lines[i].Line;
                        startDto.setupTime = lines[i].SetupTime;
                        startDto.StartTime = startTime;
                        startDto.Rate = lines[i].Rate;
                    }
                }
                //当前工序没有开始准备时间记录
                if (curRecord == null)
                {
                    //添加记录
                    inserts.Add(new WorkOrdSetupTimeRecord
                    {
                        Domain = workOrd.Domain,
                        WorkOrd = workOrd.WorkOrd,
                        ItemNum = workOrd.ItemNum,
                        Op = op,
                        Line = startDto.Line,
                        StartTime = startDto.StartTime,
                        CreateTime = DateTime.Now
                    });
                    //记录工序开始准备时间记录
                    timeRecords.Add(new WorkOrdSetupTimeRecord
                    {
                        Domain = workOrd.Domain,
                        WorkOrd = workOrd.WorkOrd,
                        ItemNum = workOrd.ItemNum,
                        Op = op,
                        Line = startDto.Line,
                        StartTime = startDto.StartTime,
                        CreateTime = DateTime.Now
                    });
                }
                else
                {
                    //更新准备开始时间记录
                    timeRecords.ForEach(p => {
                        p.Line = p.WorkOrd == workOrd.WorkOrd && p.Op == curRecord.Op ? startDto.Line : p.Line;
                        p.StartTime = p.WorkOrd == workOrd.WorkOrd && p.Op == curRecord.Op ? startDto.StartTime : p.StartTime;
                    });
                    //存在开始准备时间记录，则更新
                    curRecord.Line = startDto.Line;
                    curRecord.StartTime = startDto.StartTime;
                    updates.Add(curRecord);
                }
            }
            //计算准备开始时间点与当前时间点的有效时长
            decimal sumTimes = 0m;
            if (curRecord != null)
            {
                sumTimes = CalcTimeMins(curRecord.StartTime, startDto.StartTime, startDto.Line);
                //如果当前工单状态为生产中"W",但是，调整了日计划开工时间，则需要重新准备
                if (workOrd.Status.ToUpper() == "W" && !string.IsNullOrEmpty(workOrd.JointTyped) && workOrd.JointTyped.ToUpper() == "B")
                {
                    sumTimes = 0m;
                }
            }
            //产线准备完成之后到当前时间点剩余时长(小时)
            decimal restTime = startDto.setupTime - sumTimes / 60;
            startDto.setupTime = restTime <= 0 ? 0 : restTime;
            startDto.Op = op;
            startDto.WaitTime = routing.WaitTime * 60;

            //判断当前产线的UPH
            var curRunCrews = prodLineDetailRunCrews.Where(p => p.ProdLineDetailRecID == startDto.RecID).ToList();
            //判断当前日期是否配置了UPH
            var curLevel = curRunCrews.FirstOrDefault(p => p.StartDate.GetValueOrDefault().Date <= startDto.StartTime.Date && p.EndDate.GetValueOrDefault().Date >= startDto.StartTime.Date);
            //当天的实际UPH
            decimal rate = curLevel == null ? startDto.Rate : curLevel.Rate;

            //计算上次报工到当前时间点的预估生产数量，如果没有报工记录，则计算产线准备时间完成到当前时间点的预估生产数量
            decimal planQty = 0m;
            if (routing.Last == null && restTime < 0 && workOrd.Status.ToUpper() == "W")
            {
                //工序没有报工，使用产线准备完成之后到当前时间点剩余时长计算预估生产数量
                planQty = Math.Floor(Math.Abs(restTime) * rate);
            }
            else if (routing.Last != null)
            {
                //工序存在报工记录，计算报工时间点到当前时间点的有效生产时长，然后计算预估生产数量
                sumTimes = CalcTimeMins(routing.Last.GetValueOrDefault(), startDto.StartTime, startDto.Line);
                planQty = Math.Floor(sumTimes / 60 * rate);
            }
            //剩余待排产数量=工单数量-已报工数量-预估数量
            decimal restQty = workOrd.QtyOrded - routing.QtyComplete - planQty;
            startDto.QtyRemain = restQty < 0 ? (workOrd.QtyOrded - routing.QtyComplete) : restQty;
            return startDto;
        }

        /// <summary>
        /// 可用数量和可用时间
        /// </summary>
        /// <param name="actStart">开始时间</param>
        /// <param name="lineStart">工序</param>
        /// <param name="schedule">可插班明细</param>
        /// <param name="lines">生产线明细</param>
        /// <param name="allResults">产线占用记录</param>
        /// <param name="numList">可用数量</param>
        /// <returns></returns>
        public void AvailableQuantity(WorkOrdMaster workOrd, DateTime actStart, LineStartDto lineStart, List<ProdLineDetail> lines, List<ScheduleResultOpMaster> allResults, List<ScheduleExceptionMaster> exceptions, out List<string> numList, out ScheduleResultOpMaster schedule, out DateTime wxEndTime, bool UseSkill = true)
        {
            wxEndTime = actStart;
            numList = new List<string>();
            schedule = null;
            var num = 0;
            var scheduleList = lineStart.OpType == "P" ? new List<ScheduleResultOpMaster>() : allResults.Where(p => p.InternalEquipmentCode == lineStart.InternalEquipmentCode && ((p.WorkStartTime <= actStart && p.WorkEndTime > actStart) || p.WorkStartTime >= actStart)).OrderBy(p => p.WorkStartTime).ToList();
            if (scheduleList.Any())
            {
                schedule = null;
                for (int i = 0; i < scheduleList.Count(); i++)
                {
                    if (!string.IsNullOrEmpty(lineStart.SkillNo) && UseSkill)
                        numList = _getAvailableEquipmentAppService.GetEquipmentCountBySkillRestrictions(lineStart.SkillNo, lineStart.MoldTypeCode, lineStart.InternalEquipmentCode, actStart, allResults, lineStart.StandardStaffCount);
                    else if (!string.IsNullOrEmpty(lineStart.MoldTypeCode))
                        numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, actStart, allResults, lineStart.MoldTypeCode);
                    else if (!string.IsNullOrEmpty(lineStart.InternalEquipmentCode))
                        numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, actStart, allResults);
                    if (numList.Any() && numList.Count > 0)
                    {
                        if (Convert.ToInt32(numList[0]) > 0)
                        {
                            schedule = scheduleList[i];
                            break;
                        }
                        else
                        {
                            actStart = scheduleList[i].WorkEndTime;
                        }
                    }
                }
                //没有可插班时间
                if (schedule == null)
                {
                    schedule = scheduleList[scheduleList.Count - 1];
                }
            }
            else
            {
                if (!string.IsNullOrEmpty(lineStart.SkillNo) && UseSkill)
                    numList = _getAvailableEquipmentAppService.GetEquipmentCountBySkillRestrictions(lineStart.SkillNo, lineStart.MoldTypeCode, lineStart.InternalEquipmentCode, actStart, allResults, lineStart.StandardStaffCount);
                else if (!string.IsNullOrEmpty(lineStart.MoldTypeCode))
                    numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, actStart, allResults, lineStart.MoldTypeCode);
                else if (!string.IsNullOrEmpty(lineStart.InternalEquipmentCode))
                    numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, actStart, allResults);
            }
            //占用时间过后依然无可用设备
            if (scheduleList.Any() && numList.Any() && numList.Count > 0 || (scheduleList.Any() && num == 0 && numList.Count == 0))
            {
                num = numList.Count > 0 ? Convert.ToInt32(numList[0]) : 0;
                //无可用设备
                if (num <= 0)
                {
                    if (num == -99)
                    {
                        var entity = new ScheduleExceptionMaster();
                        entity.Domain = workOrd.Domain;
                        entity.WorkOrd = workOrd.WorkOrd;
                        entity.ItemNum = workOrd.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = $"{workOrd.WorkOrd}排产异常：{lineStart.Op}-{numList[1]}";
                        entity.Type = "手动排产";
                        entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                        exceptions.Add(entity);
                    }
                    else
                    {
                        //是否是维修
                        wxEndTime = num < 0 ? (numList.Count >= 3 ? Convert.ToDateTime(numList[2]) : schedule.WorkEndTime) : schedule.WorkEndTime;
                        if (!string.IsNullOrEmpty(lineStart.SkillNo) && UseSkill)
                            numList = _getAvailableEquipmentAppService.GetEquipmentCountBySkillRestrictions(lineStart.SkillNo, lineStart.MoldTypeCode, lineStart.InternalEquipmentCode, wxEndTime, allResults, lineStart.StandardStaffCount);
                        else if (!string.IsNullOrEmpty(lineStart.MoldTypeCode))
                            numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, wxEndTime, allResults, lineStart.MoldTypeCode);
                        else if (!string.IsNullOrEmpty(lineStart.InternalEquipmentCode))
                            numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, wxEndTime, allResults);

                    }
                }
            }
            if (numList.Count > 0)
            {
                if (Convert.ToInt32(numList[0]) == -99 && exceptions.FindIndex(e => e.WorkOrd == workOrd.WorkOrd) < 0)
                {
                    var entity = new ScheduleExceptionMaster();
                    entity.Domain = workOrd.Domain;
                    entity.WorkOrd = workOrd.WorkOrd;
                    entity.ItemNum = workOrd.ItemNum;
                    entity.CreateTime = DateTime.Now;
                    entity.Remark = $"{workOrd.WorkOrd}排产异常：{lineStart.Op}-{numList[1]}";
                    entity.Type = "手动排产";
                    entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                    exceptions.Add(entity);
                }
                else if (Convert.ToInt32(numList[0]) == 0)
                {
                    for (int i = 1; i < 10; i++)
                    {
                        var newtime = actStart.AddHours(12 * i);
                        if (!string.IsNullOrEmpty(lineStart.SkillNo) && UseSkill)
                            numList = _getAvailableEquipmentAppService.GetEquipmentCountBySkillRestrictions(lineStart.SkillNo, lineStart.MoldTypeCode, lineStart.InternalEquipmentCode, newtime, allResults, lineStart.StandardStaffCount);
                        else if (!string.IsNullOrEmpty(lineStart.MoldTypeCode))
                            numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, newtime, allResults, lineStart.MoldTypeCode);
                        else if (!string.IsNullOrEmpty(lineStart.InternalEquipmentCode))
                            numList = _getAvailableEquipmentAppService.GetAvailableEquipmentForCurrentTeam(lineStart.InternalEquipmentCode, newtime, allResults);
                        if (Convert.ToInt32(numList[0]) > 0)
                        {
                            break;
                        }
                    }
                    if (Convert.ToInt32(numList[0]) == -99)
                    {
                        var entity = new ScheduleExceptionMaster();
                        entity.Domain = workOrd.Domain;
                        entity.WorkOrd = workOrd.WorkOrd;
                        entity.ItemNum = workOrd.ItemNum;
                        entity.CreateTime = DateTime.Now;
                        entity.Remark = $"{workOrd.WorkOrd}排产异常：{lineStart.Op}-{numList[1]}";
                        entity.Type = "手动排产";
                        entity.OptTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                        exceptions.Add(entity);
                    }
                }
            }
        }


        /// <summary>
        /// 通过提前期计算产线排产开始时间
        /// </summary>
        /// <param name="line">产线</param>
        /// <param name="startTime">上一产线开始时间</param>
        /// <param name="setupTime">上一产线准备时间+当前产线提前期</param>
        /// <returns></returns>
        public DateTime CalcStartTimeWithSetUpTime(ProdLineDetail line, DateTime startTime, decimal setupTime)
        {
            //提前期转换成分钟
            decimal needMinute = setupTime * 60;
            //实际排产开始时间
            DateTime actStart = startTime;
            //开始时间是周几
            int weekDay = (int)startTime.DayOfWeek;
            //当天的工作日历
            var shopCal = calendars.Where(p => p.ProdLine == line.Line && p.WeekDay == weekDay).FirstOrDefault();
            if (shopCal == null)
            {
                //产线没有维护当天的工作日历，则取默认工作日历
                shopCal = calendars.Where(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == weekDay).FirstOrDefault();
            }
            //当前产线的休息时间设置
            var curQtyDtls = qualityLines.Where(p => p.ProdLine == line.Line).ToList();
            //当前日期的工作时间段
            List<LineWorkPointDto> workPoints = DealWorkDayToLevels(line.Line, startTime, shopCal, curQtyDtls);
            //计算starttime处于那个工作时间段
            var curPoint = workPoints.Where(p => startTime >= p.StartPoint && startTime <= p.EndPoint).FirstOrDefault();
            //如果找不到对应时间段
            if (curPoint == null)
            {
                //如果开始时间在开始上班之前
                if (startTime < workPoints.First().StartPoint)
                {
                    curPoint = workPoints.First();
                    startTime = curPoint.StartPoint;
                }
                else {
                    //判断开始时间处于哪个空闲时间段
                    curPoint = workPoints.Where(p => startTime > p.EndPoint).OrderBy(p => p.Level).Last();
                    startTime = curPoint.EndPoint;
                }
            }
            //当前时间段可用时长
            TimeSpan span = curPoint.EndPoint - startTime;
            decimal curMins = (decimal)span.TotalMinutes;
            if (curMins >= needMinute)//当前时间段的可用时长满足提前期
            {
                actStart = startTime.AddMinutes((double)needMinute);
                return actStart;
            }
            //当前时间段的可用时长不满足
            //剩余提前期
            needMinute -= curMins;
            //获取后层级时间段
            var prePoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
            bool flag = true;//标志位
            foreach (var item in prePoints)
            {
                if (item.WorkMinutes >= needMinute)//当前时间段的可用时长满足
                {
                    actStart = item.StartPoint.AddMinutes((double)needMinute);
                    flag = false;
                    break;
                }
                needMinute -= item.WorkMinutes;
            }
            if (!flag)
            {
                return actStart;
            }
            //今天可用时长不够，往后工作日找
            DateTime nextStartTime = startTime;
            while (flag)
            {
                //获取下一个工作日
                nextStartTime = GetNextWorkDay(weekDay, startTime, calendars.Where(p => p.ProdLine == line.Line || string.IsNullOrEmpty(p.ProdLine)).ToList());
                weekDay = (int)nextStartTime.DayOfWeek;
                //获取前一个工作日的工作时间段数据,level顺排
                var curCalendar = calendars.Where(p => p.ProdLine == line.Line && p.WeekDay == weekDay).FirstOrDefault();
                if (curCalendar == null )
                {
                    curCalendar = calendars.Where(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == weekDay).FirstOrDefault();
                }
                workPoints = DealWorkDayToLevels(line.Line, nextStartTime, curCalendar, curQtyDtls).OrderBy(p => p.Level).ToList();
                //当天的工作时长(分钟)
                decimal sumWorkMins = workPoints.Sum(p => p.WorkMinutes);
                if (sumWorkMins >= needMinute)//当天可用提前期满足
                {
                    //获取开始时间
                    foreach (var item in workPoints)
                    {
                        if (item.WorkMinutes >= needMinute)//当前时间段满足
                        {
                            actStart = item.StartPoint.AddMinutes((double)needMinute);
                            break;
                        }
                        needMinute -= item.WorkMinutes;
                    }
                    flag = false;
                }
                else
                {
                    //当天可用提前期不满足
                    needMinute -= sumWorkMins;
                }
            }
            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 =>!string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == nextWeekDay);
            if (calendar == null)
            {
                calendar = curCalendars.FirstOrDefault(p => string.IsNullOrEmpty(p.ProdLine) && p.WeekDay == nextWeekDay);
            }
            string strStart = calendar.ShiftsStart1.ToString("0.00").Replace(".", ":");
            //判断下一天是否是工作日
            if (nextWeekDay == 0 || nextWeekDay == 6)//下一天是周六或者周日，需要判断是否调班，需要加班
            {
                if (!holidays.Exists(p => p.Dated.GetValueOrDefault().Date == nextDate && p.Ufld1 == "调班"))//下一天是周末
                {
                    //递归继续找下一个工作日
                    rtnData = GetNextWorkDay(nextWeekDay, nextDate, curCalendars);
                    return rtnData;
                }
                rtnData = Convert.ToDateTime(nextDate.ToString("yyyy-MM-dd") + " " + strStart);
                return rtnData;
            }
            //下一天不是周六周日，需要判断是不是节假日
            if (holidays.Exists(p => p.Dated.GetValueOrDefault().Date == nextDate && p.Ufld1 == "休假"))//是节假日
            {
                //递归继续找下一个工作日
                rtnData = GetNextWorkDay(nextWeekDay, nextDate, curCalendars);
                return rtnData;
            }
            rtnData = Convert.ToDateTime(nextDate.ToString("yyyy-MM-dd") + " " + strStart);
            return rtnData;
        }

        /// <summary>
        /// 处理当前日期的工作时间段
        /// </summary>
        /// <param name="prodLine"></param>
        /// <param name="startTime"></param>
        /// <param name="shopCal">当前产线的工作日历-周几</param>
        /// <param name="curQtyDtls">每天休息记录</param>
        /// <returns></returns>
        public List<LineWorkPointDto> DealWorkDayToLevels(string prodLine, DateTime startTime, ShopCalendarWorkCtr shopCal, List<QualityLineWorkDetail> curQtyDtls)
        {
            //年-月-日
            string date = startTime.Date.ToString("yyyy-MM-dd");
            //排产记录结束日期是周几
            int weekDay = (int)startTime.DayOfWeek;
            //工作时间段
            List<LineWorkPointDto> workPoints = new List<LineWorkPointDto>();
            LineWorkPointDto dto = new LineWorkPointDto();
            int level = 1;
            TimeSpan span = TimeSpan.Zero;
            //开始时间
            string strStart = shopCal.ShiftsStart1.ToString("0.00").Replace(".", ":");
            DateTime dayStartPoint = Convert.ToDateTime(date + " " + strStart);
            //结束时间
            DateTime dayEndPoint = dayStartPoint.AddHours((double)(shopCal.ShiftsHours1 + shopCal.ShiftsHours2));
            dto.Level = level;
            dto.Line = prodLine;
            dto.WeekDay = weekDay;
            dto.StartPoint = dayStartPoint;
            //按照产线休息时间切分时间段
            curQtyDtls = curQtyDtls.OrderBy(p => p.RestTimePoint).ToList();
            foreach (var item in curQtyDtls)
            {
                DateTime endPoint = Convert.ToDateTime(date + " " + item.RestTimePoint);
                //休息时间段开始时间不在工作时间内，不考虑
                if (endPoint < dayStartPoint || endPoint > dayEndPoint)
                {
                    continue;
                }
                dto.EndPoint = endPoint;
                span = dto.EndPoint - dto.StartPoint;
                dto.WorkMinutes = (decimal)span.TotalMinutes;
                workPoints.Add(dto);
                level++;
                dto = new LineWorkPointDto();
                dto.Level = level;
                dto.Line = prodLine;
                dto.WeekDay = weekDay;
                dto.StartPoint = endPoint.AddMinutes(item.RestTime);
            }
            dto.EndPoint = dayEndPoint;
            span = dto.EndPoint - dto.StartPoint;
            dto.WorkMinutes = (decimal)span.TotalMinutes;
            workPoints.Add(dto);
            //产线当天加班设置
            var curOccupyTimes = resourceOccupancyTimes.Where(p => p.Resource == prodLine && p.StartTime.GetValueOrDefault().Date == startTime.Date).OrderBy(p=>p.StartTime).ToList();
            foreach (var item in curOccupyTimes)
            {
                //如果加班开始时间在工作时间内，则不考虑
                if (item.StartTime.GetValueOrDefault() < dayEndPoint)
                {
                    continue;
                }
                level++;
                dto = new LineWorkPointDto();
                dto.Level = level;
                dto.Line = prodLine;
                dto.WeekDay = weekDay;
                dto.StartPoint = item.StartTime.GetValueOrDefault();
                dto.EndPoint = dto.StartPoint.AddHours(Convert.ToDouble(item.Ufld1));
                dto.WorkMinutes = Convert.ToDecimal(item.Ufld1) * 60;
                workPoints.Add(dto);
            }
            return workPoints.OrderBy(p => p.Level).ToList();
        }

        /// <summary>
        /// 调整领料单时间
        /// </summary>
        /// <param name="workords"></param>
        public void AdjustNbrDate(List<WorkOrdMaster> workords)
        {
            if (workords.Any())
            {
                //找出当前工单的所有领料单，更新领料单的前处理时间和完成日期。
                //1.如果未生成领料单，则无需调整。
                //2.已生成领料单，但是领料单已出库，也不调整。nbr.Status='C'
                //3.当领料单未出库，则代表需要调整这个领料单的处理时间。
                var nbrlist = _nbrMaster.Select(s => workords.Select(x => x.WorkOrd).Contains(s.WorkOrd) && s.Domain == workords[0].Domain).ToList();
                if (nbrlist.Any())
                {
                    foreach (var work in workords)
                    {
                        var workNbr = nbrlist.Where(s => s.WorkOrd == work.WorkOrd).ToList();
                        foreach (var nbr in workNbr)
                        {
                            if (string.IsNullOrEmpty(nbr.Status))
                            {
                                if (nbr.TransType == "PrevProcess")
                                {
                                    //前处理领料单
                                    var ts = nbr.EffDate.GetValueOrDefault() - nbr.Date.GetValueOrDefault();
                                    nbr.EffDate = work.OrdDate.GetValueOrDefault().AddDays(-1);
                                    nbr.Date = nbr.EffDate.GetValueOrDefault().AddDays(-ts.Days);
                                }
                                else
                                {
                                    nbr.EffDate = work.OrdDate.GetValueOrDefault().AddDays(-1);
                                    nbr.Date = nbr.EffDate;
                                }
                                if (nbr.Date.GetValueOrDefault().Date <= DateTime.Now.Date)
                                {
                                    nbr.Date = DateTime.Now.AddDays(1).Date;
                                }
                                if (nbr.EffDate.GetValueOrDefault().Date <= DateTime.Now.Date)
                                {
                                    nbr.EffDate = DateTime.Now.AddDays(1).Date;
                                }
                            }
                        }
                    }
                    _nbrMaster.Update(nbrlist);
                }
            }
        }

        /// <summary>
        /// 日计划自动发布
        /// </summary>
        public async Task<string> ProductionDailyPlanAutoPublish(string domain)
        {
            //取数开始时间为当前日期
            DateTime startTime = DateTime.Now.Date;
            DateTime endDate = DateTime.Now.Date.AddDays(6);

            var periodList = _periodSequenceDet.Select(x => x.PlanDate >= startTime && x.PlanDate <= endDate && string.IsNullOrEmpty(x.Status) == true && x.Domain == domain).ToList();
            if (periodList.Any())
            {
                try
                {
                    List<PeriodSequenceDet> updateList = new List<PeriodSequenceDet>();
                    var workords = periodList.Select(s => s.WorkOrds);
                    var workordList = _workOrdMaster.Select(x => x.Domain == domain && x.Status.ToLower() == "r" && workords.Contains(x.WorkOrd)).ToList();
                    var nbrMasterList = _nbrMaster.Select(x => x.Domain == domain && x.Type == "SM" && workords.Contains(x.WorkOrd)).ToList();
                    var nbrDetailList = _nbrDetail.Select(x => x.Domain == domain && x.Type == "SM" && workords.Contains(x.WorkOrd)).ToList();
                    foreach (var work in workordList)
                    {
                        bool flag = false;
                        var nbrlist = nbrMasterList.Where(s => s.WorkOrd == work.WorkOrd).ToList();
                        if (nbrlist.Any())
                        {
                            flag = true;
                            foreach (var nbr in nbrlist)
                            {
                                //还有未出库数据
                                //如果有任意一个出库，则下达
                                if (!nbrDetailList.Where(x => x.NbrRecID == nbr.RecID && x.Status.ToUpper() == "C").Any())
                                {
                                    flag = false;
                                    break;
                                }
                                /*if (nbr.Status.ToLower() != "c")
                                {
                                    flag = false;
                                    break;
                                }*/
                                //需要前处理，但是前处理还未完成
                                if (nbr.TransType == "PrevProcess" && nbr.PretreatmentState != "completed" && nbr.PretreatmentState != "50")
                                {
                                    flag = false;
                                    break;
                                }
                            }
                        }
                        if (flag)
                        {
                            var publish = periodList.Where(x => x.WorkOrds == work.WorkOrd).ToList();
                            publish.ForEach(x =>
                            {
                                x.Status = "r";
                            });
                            updateList.AddRange(publish);
                        }
                    }
                    if (updateList.Any())
                    {
                        _periodSequenceDet.Update(updateList);
                    }
                }
                catch (Exception e)
                {
                    new NLogHelper("ResourceExamineAppService").WriteLog("ProductionDailyPlanAutoPublish", "日计划自动任务失败：" + e.Message, _currentTenant.Id.ToString());
                    return "保存失败，请联系管理员。";
                }
            }
            return "ok";
        }
    }
}