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;

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<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>
        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>
        /// 工厂id
        /// </summary>
        private string domain = "";
        #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
            )
        {
            _itemMaster = itemMaster;
            _workOrdMaster = workOrdMaster;
            _workOrdDetail = workOrdDetail;
            _workOrdRouting = workOrdRouting;
            _prodLineDetail = prodLineDetail;
            _prodLineDetailRunCrew = prodLineDetailRunCrew;
            _resourceOccupancyTime = resourceOccupancyTime;
            _periodSequenceDet = periodSequenceDet;
            _scheduleResultOpMaster = scheduleResultOpMaster;
            _invMaster = invMaster;
            _shopCalendarWorkCtr = shopCalendarWorkCtr;
            _qualityLineWorkDetail = qualityLineWorkDetail;
            _holidayMaster = holidayMaster;
            _generalizedCodeMaster = generalizedCodeMaster;
            _currentTenant = currentTenant;
            _scheduleExceptionMaster = scheduleExceptionMaster;
        }
        #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 startDate = DateTime.Now.Date.AddDays(1);
            //尚未开始生产的工单+正在生产的工单
            var workOrds = _workOrdMaster.Select(p => p.IsActive && p.Domain == domain && ((p.OrdDate < endDate && p.OrdDate >= startDate && (string.IsNullOrEmpty(p.Typed) || (!string.IsNullOrEmpty(p.Typed) && p.BusinessID >0 ))) || p.Status.ToLower() == "w")).ToList();
            await DoProductSchedule(workOrds, domain, 1);
        }

        /// <summary>
        /// 生产排产
        /// </summary>
        /// <param name="workOrds">需要重新排产的工单</param>
        /// <param name="factoryid">工单的工厂id</param>
        /// <param name="type">排产类型：1-自动排产；2-手动排产</param>
        /// <returns></returns>
        public async Task DoProductSchedule(List<WorkOrdMaster> workOrds, string factoryid,int type)
        {
            //记录工厂id
            domain = factoryid;
            if (workOrds.Count == 0)//没有工单需要排产
            {
                return;
            }
            //工单排产的最早日期
            DateTime earlist = DateTime.Now.Date.AddDays(1);
            //特殊工单指定时间开工，不需要计算产能，只需要计算时长即可
            var tsWorkOrds = workOrds.Where(p => !string.IsNullOrEmpty(p.Typed)).ToList();
            //正常工单
            var zcWorkOrds = workOrds.Where(p => string.IsNullOrEmpty(p.Typed)).ToList();

            //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<WorkOrdRouting> tsWoRoutings = workOrdRoutings.Where(p => tsWorkOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd)).ToList();
            //获取物料对应的生产线信息:物料、工序对应的生产线
            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<PeriodSequenceDet> dbPeriodSequences = _periodSequenceDet.Select(p => lines.Contains(p.Line) && p.PlanDate >= earlist && p.Domain == domain && p.IsActive);
            //获取当前日期往后的排产记录数据
            List<ScheduleResultOpMaster> dbSchedules = _scheduleResultOpMaster.Select(p => lines.Contains(p.Line) && p.WorkDate >= earlist && p.Domain == domain);
            ////获取锁定期之外的工单排产数据
            //List<PeriodSequenceDet> delPeriodSequences = dbPeriodSequences.Where(p => workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrds)).ToList();
            //List<ScheduleResultOpMaster> delSchedules = dbSchedules.Where(p => workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd)).ToList();
            ////产线占用记录排除锁定期之前的工单
            //dbSchedules = dbSchedules.Where(p => !workOrds.Select(m => m.WorkOrd).Contains(p.WorkOrd)).ToList();
            //获取工作日历数据:产线的工作日历+默认的工作日历
            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);
            //获取节假日记录数据
            holidays = _holidayMaster.Select(p => p.Domain == domain && p.IsActive && p.Dated >= earlist);

            //排产前校验
            List<ScheduleExceptionMaster> exceptions = BeforeScheduleCheck(workOrds, workOrdRoutings, prodLines,type);
            if (exceptions.Any())
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    try
                    {
                        //记录排产异常数据
                        _scheduleExceptionMaster.Insert(exceptions);
                        scope.Complete();
                    }
                    catch (Exception ex)
                    {
                        new NLogHelper("ProductionScheduleAppService").WriteLog("DoProductSchedule", "保存排产异常数据失败：" + ex.Message, _currentTenant.Id.ToString());
                        scope.Dispose();
                    }
                }
                return;
            }
            
            //3、排产
            //生产周期
            List<PeriodSequenceDet> periodSequenceDtls = new List<PeriodSequenceDet>();
            //排产记录表
            List<ScheduleResultOpMaster> scheduleMasters = new List<ScheduleResultOpMaster>();
            //记录排产结果
            List<ScheduleResultOpMaster> allResults = new List<ScheduleResultOpMaster>();
            //allResults.AddRange(dbSchedules);
            //记录特殊工单排产结果
            List<string> ypcWorkOrds = new List<string>();
            //按照优先级排序
            zcWorkOrds = zcWorkOrds.OrderBy(p=>p.Priority).ToList();
            foreach (var item in zcWorkOrds)
            {
                //记录产线占用情况
                allResults.AddRange(scheduleMasters);
                //当前工单工艺路线主产线的关键工序
                var curRoutings = workOrdRoutings.Where(p => p.ItemNum == item.ItemNum && p.ParentOp == 0 && p.MilestoneOp).OrderBy(p=>p.OP).ToList();
                //当前工单的产线明细
                var curProdLines = prodLines.Where(p => p.Part == item.ItemNum).ToList();
                
                //产线排产
                LineSchedule(item, curRoutings, curProdLines, periodSequenceDtls, scheduleMasters, allResults, tsWorkOrds, ypcWorkOrds, tsWoRoutings);

                List<ScheduleResultOpMaster> scheduleList = scheduleMasters.Where(s => s.WorkOrd == item.WorkOrd).ToList();
                if (scheduleList.Any())
                {
                    item.OrdDate = scheduleList.Min(s => s.WorkStartTime);
                    item.DueDate = scheduleList.Max(s => s.WorkEndTime);
                }
            }
            //判断是否有特殊工单没有排产，如果有，则对剩余特殊工单排产
            var notSchedules = tsWorkOrds.Where(p => !ypcWorkOrds.Contains(p.WorkOrd)).ToList();
            List<WorkOrdMstDto> workDtos = new List<WorkOrdMstDto>();
            foreach (var item in notSchedules)
            {
                var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
                //剩余排产数量
                decimal qtyNeed = item.QtyOrded - curOp.QtyComplete;
                //剩余工作时长(分钟)
                decimal usedTime = Math.Ceiling(qtyNeed / item.QtyOrded * item.LbrVar * 60);
                //特殊工单排产开始时间
                DateTime startTime = item.OrdDate.GetValueOrDefault();
                //如果当前特殊工单正在生产，则开工日期为当天的下一个工作日
                if (item.Status.ToLower() == "w" && item.JointTyped.ToUpper() != "B")
                {
                    DateTime nowDate = DateTime.Now.Date;
                    //当前产线的工作日历
                    var mLCalendars = calendars.Where(p => p.ProdLine == item.ProdLine || string.IsNullOrEmpty(p.ProdLine)).ToList();
                    //获取下一个工作日
                    startTime = GetNextWorkDay((int)nowDate.DayOfWeek, nowDate, mLCalendars);
                }
                workDtos.Add(new WorkOrdMstDto
                {
                    WorkOrd = item.WorkOrd,
                    ItemNum = item.ItemNum,
                    QtyOrded = qtyNeed,
                    OrdDate = startTime,
                    ProdLine = item.ProdLine,
                    LbrVar = usedTime,
                    Worked = 0,
                    QtyWorked = 0,
                    Op = curOp.OP,
                    WaitTime = curOp.WaitTime * 60
                });
            }
            TsLineSchedule(workDtos, periodSequenceDtls, scheduleMasters);
            //处理特殊工单计划开始日期、计划结束日期
            foreach (var item in tsWorkOrds)
            {
                List<ScheduleResultOpMaster> scheduleList = scheduleMasters.Where(s => s.WorkOrd == item.WorkOrd).ToList();
                if (scheduleList.Any())
                {
                    item.OrdDate = scheduleList.Min(s => s.WorkStartTime);
                    item.DueDate = scheduleList.Max(s => s.WorkEndTime);
                }
            }
            using (TransactionScope scope = new TransactionScope())
            {
                try
                {
                    //更新工单计划开工时间、计划结束时间
                    _workOrdMaster.Update(workOrds);
                    //删除当前日期下一天开始的工单排产记录
                    _periodSequenceDet.Delete(dbPeriodSequences);
                    _scheduleResultOpMaster.Delete(dbSchedules);
                    //保存排产记录
                    _periodSequenceDet.Insert(periodSequenceDtls);
                    _scheduleResultOpMaster.Insert(scheduleMasters);
                    scope.Complete();
                }
                catch (Exception ex)
                {
                    new NLogHelper("ProductionScheduleAppService").WriteLog("DoProductSchedule", "保存排产数据失败：" + ex.Message, _currentTenant.Id.ToString());
                    scope.Dispose();
                }
            }
        }

        /// <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) 
        {
            List<ScheduleExceptionMaster> exceptions = new List<ScheduleExceptionMaster>();
            ScheduleExceptionMaster entity;
            foreach (var item in workOrds)
            {
                if (!string.IsNullOrEmpty(item.Typed))//特殊工单
                {
                    //校验有没有维护工艺路线即可
                    var routings = workOrdRoutings.Where(p=>p.ItemNum == item.ItemNum).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 ? "自动排产" : "手动排产";
                        exceptions.Add(entity);
                    }

                    //获取当前产线维护的工作日历
                    var lineCals = calendars.Where(p => p.ProdLine == item.ProdLine).ToList();
                    //获取默认工作日历
                    var mrCals = calendars.Where(p => string.IsNullOrEmpty(p.ProdLine)).ToList();
                    if (!lineCals.Any())//当前产线未维护工作日历
                    {
                        if (!mrCals.Any() || mrCals.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 = "排产异常：产线[" + item.ProdLine + "]没有维护工作日历且标准工作日历未维护完全，请维护后再操作！";
                            entity.Type = type == 1 ? "自动排产" : "手动排产";
                            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 = "排产异常：产线[" + item.ProdLine + "]工作日历没有维护完整，请维护后再操作！";
                        entity.Type = type == 1 ? "自动排产" : "手动排产";
                        exceptions.Add(entity);
                    }
                    continue;
                }
                var curRoutings = workOrdRoutings.Where(p => 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 ? "自动排产" : "手动排产";
                    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 ? "自动排产" : "手动排产";
                    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 ? "自动排产" : "手动排产";
                        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()) + "]对应同一条产线，请调整后再操作！";
                        entity.Type = type == 1 ? "自动排产" : "手动排产";
                        exceptions.Add(entity);
                    }
                }
                
                //校验主产线关键工序对应的产线是否维护了工作日历
                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 ? "自动排产" : "手动排产";
                            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 ? "自动排产" : "手动排产";
                        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>
        /// <param name="tsWorkOrds">特殊工单</param>
        /// <param name="ypcWorkOrds">已排产特殊工单的工单编号</param>
        /// <param name="tsWoRoutings">特殊工单的工艺路线</param>
        public void LineSchedule(WorkOrdMaster workOrd, List<WorkOrdRouting> workOrdRoutings, List<ProdLineDetail> prodLines,List<PeriodSequenceDet> periodsDet, List<ScheduleResultOpMaster> scheduleResults, List<ScheduleResultOpMaster> allResults,List<WorkOrdMaster> tsWorkOrds,List<string> ypcWorkOrds, List<WorkOrdRouting> tsWoRoutings)
        {
            //生产周期
            List<PeriodSequenceDet> curSequences = new List<PeriodSequenceDet>();
            //排产明细
            List<ScheduleResultOpMaster> curScheduleRsts = new List<ScheduleResultOpMaster>();
            //记录上一产线排产开始时间
            LineStartDto lineStart = new LineStartDto();
            //产线开工时间默认为当前日期的下一天
            lineStart.StartTime = DateTime.Now.Date.AddDays(1);
            TimeSpan span = TimeSpan.Zero;
            //第一层级工序有几个关键工序，就有几条产线
            for (int i = 0; i < workOrdRoutings.Count; i++)
            {
                //如果当前工序已经生产完成，则跳过
                if (workOrdRoutings[i].QtyComplete == workOrd.QtyOrded)
                {
                    continue;
                }
                //产线实际排产开始时间
                if (i == 0)//第一条产线
                {
                    lineStart = DealStartTime(workOrd, workOrdRoutings[i], prodLines, allResults);
                }
                else
                {
                    //获取前一产线排产开始时间,通过提前期计算当前产线排产开始时间
                    lineStart = DealNextStartTime(workOrd, lineStart, workOrdRoutings[i], prodLines, allResults);
                }
                //当前产线的工作日历
                var mLCalendars = calendars.Where(p => p.ProdLine == lineStart.Line || string.IsNullOrEmpty(p.ProdLine)).ToList();
                //当前产线的休息时间设置
                var mlqtyWorkDtls = qualityLines.Where(p => p.ProdLine == lineStart.Line).ToList();
                //产线排产开始时间
                DateTime workStartTime = lineStart.StartTime;
                //记录特殊工单：获取第一天是否有特殊工单
                List<WorkOrdMaster> fstWOMasters = tsWorkOrds.Where(p => p.ProdLine == lineStart.Line && p.OrdDate.Value.Date == workStartTime.Date).OrderBy(p => p.Priority).ToList();
                List<WorkOrdMstDto> workDtos = new List<WorkOrdMstDto>();
                //记录排产开始第二天及以后安排的特殊工单
                var secWOMasters = new List<WorkOrdMaster>();
                //特殊工单总清场时长(分钟)
                decimal sumCleanTimes = 0m;
                //最后一个特殊工单的清场时长(分钟)
                decimal lstCleanTime = 0m;
                //新增特殊工单最后一个清场时长
                decimal secCleanTime = 0m;
                //特殊工单排产需要考虑的时长
                decimal sumTsTimes = 0m;
                if (fstWOMasters.Any())
                {
                    foreach (var item in fstWOMasters)
                    {
                        var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
                        //剩余排产数量
                        decimal qtyNeed = item.QtyOrded - curOp.QtyComplete;
                        //剩余工作时长(分钟)
                        decimal usedTime = Math.Ceiling(qtyNeed / item.QtyOrded * item.LbrVar * 60);
                        workDtos.Add(new WorkOrdMstDto
                        {
                            WorkOrd = item.WorkOrd,
                            ItemNum = item.ItemNum,
                            QtyOrded = qtyNeed,
                            LbrVar = usedTime,
                            Worked = 0,
                            QtyWorked = 0,
                            Op = curOp.OP,
                            WaitTime = curOp.WaitTime * 60,
                            Priority = item.Priority
                        });
                        sumCleanTimes += curOp.WaitTime * 60;
                    }
                    //获取最后一个特殊工单的清场时长
                    var last = fstWOMasters.Last();
                    lstCleanTime = tsWoRoutings.Where(p => p.WorkOrd == last.WorkOrd).OrderByDescending(p => p.OP).First().WaitTime * 60;
                    //特殊工单排产需要考虑的时长=特殊工单工作时长(分钟)+除最后一个特殊工单之外的清场时长
                    sumTsTimes = workDtos.Sum(p => p.LbrVar) + sumCleanTimes - lstCleanTime;
                }
                //工单排产第一天标识
                bool isFstDay = true;
                //产线排产开始当天安排了特殊工单，则先安排特殊工单
                while (sumTsTimes > 0)
                {
                    secWOMasters.Clear();
                    //获取当天的产能
                    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 (dto.EffTime > sumTsTimes && !isFstDay)
                    {
                        //获取特殊工单
                        secWOMasters = tsWorkOrds.Where(p => p.ProdLine == lineStart.Line && p.OrdDate.Value.Date == workStartTime.Date).OrderBy(p => p.Priority).ToList();
                        if (secWOMasters.Any())
                        {
                            sumCleanTimes = 0m;
                            //新增特殊工单最后一个清场时长
                            secCleanTime = 0m;
                            //生产时长
                            decimal sumLbrVar = 0m;
                            //记录新增待排产特殊工单
                            foreach (var item in secWOMasters)
                            {
                                var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
                                //剩余排产数量
                                decimal qtyNeed = item.QtyOrded - curOp.QtyComplete;
                                //剩余工作时长(分钟)
                                decimal usedTime = Math.Ceiling(qtyNeed / item.QtyOrded * item.LbrVar * 60);
                                workDtos.Add(new WorkOrdMstDto
                                {
                                    WorkOrd = item.WorkOrd,
                                    ItemNum = item.ItemNum,
                                    QtyOrded = qtyNeed,
                                    LbrVar = usedTime,
                                    Worked = 0,
                                    QtyWorked = 0,
                                    Op = curOp.OP,
                                    WaitTime = curOp.WaitTime * 60,
                                    Priority = item.Priority
                                });
                                sumLbrVar += usedTime;
                                sumCleanTimes += curOp.WaitTime * 60;
                            }
                            //获取最后一个特殊工单的清场时长
                            var last = secWOMasters.Last();
                            secCleanTime = tsWoRoutings.Where(p => p.WorkOrd == last.WorkOrd).OrderByDescending(p => p.OP).First().WaitTime * 60;
                            //特殊工单待排产时长=前一天特殊工单到最后一个清场时长+新增的特殊工单生产时长+新增特殊工单除最后一个清场时长之外的清场时长之和
                            sumTsTimes += (lstCleanTime + sumLbrVar + sumCleanTimes - secCleanTime);
                            lstCleanTime = secCleanTime;
                        }
                    }
                    //特殊工单排序
                    workDtos = workDtos.OrderBy(p => p.Priority).ToList();
                    //当天的可用生产时长满足特殊工单生产时长+清场时间(最后一个工单清场时间除外)
                    if (dto.EffTime >= sumTsTimes)
                    {
                        //可用生产时长(分钟)
                        decimal remainTime = dto.EffTime;
                        DateTime beginTime = workStartTime;
                        DateTime endTime = dto.EndTime;
                        //获取最后一个工单
                        var lastWork = workDtos.Last();
                        //开始或结束时间所处时间段
                        var curPoint = new LineWorkPointDto();
                        //特殊工单排产
                        foreach (var item in workDtos)
                        {
                            //当前工单已排产，跳过
                            if (item.LbrVar == item.Worked)
                            {
                                continue;
                            }
                            //当前工单排产需要时长
                            decimal needTime = 0m;
                            //最后一个特殊工单
                            if (item.WorkOrd == lastWork.WorkOrd)
                            {
                                //最后一个工单的生产时长+清场时长
                                needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                if (remainTime >= needTime)
                                {
                                    //计算工单排产结束时间
                                    curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                    //获取排产结束时间所处以及之后的生产时间段
                                    var nextPoints = workPoints.Where(p => p.Level >= curPoint.Level).OrderBy(p => p.Level).ToList();
                                    //处理第一个时间段的开始时间
                                    nextPoints[0].StartPoint = beginTime;
                                    foreach (var p in nextPoints)
                                    {
                                        span = p.EndPoint - p.StartPoint;
                                        //当前工作时间段的有效生产时间
                                        decimal effMins = (decimal)span.TotalMinutes;
                                        if (effMins >= needTime)
                                        {
                                            endTime = p.StartPoint.AddMinutes((double)needTime);
                                            break;
                                        }
                                        needTime -= effMins;
                                        remainTime -= effMins;
                                    }
                                    remainTime -= needTime;
                                }
                                //剩余可用工作时长不能满足清场时长
                                else
                                {
                                    //还需排产的清场时间
                                    decimal qcTime = needTime - remainTime;
                                    endTime = dto.EndTime.AddMinutes((double)qcTime);
                                    remainTime = 0;
                                }
                                //最后一个工单的清场时长
                                lstCleanTime = 0m;
                            }
                            //最后一个特殊工单之前的工单：剩余排产时长和清场时间全部排产
                            else {
                                //当前工单还需工作时长+工单的清场时长
                                needTime = item.LbrVar - item.Worked + item.WaitTime;
                                //计算工单排产结束时间
                                curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                span = curPoint.EndPoint - beginTime;
                                //当天工作时间段的有效生产时间(分钟)
                                decimal effMins = (decimal)span.TotalMinutes;
                                if (effMins >= needTime)//当前工作时间段即可满足产能
                                {
                                    endTime = beginTime.AddMinutes((double)needTime);
                                }
                                else
                                {
                                    //获取后续生产时间段
                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                    //剩余需要工作时长
                                    decimal nextMins = needTime - effMins;
                                    foreach (var p in nextPoints)
                                    {
                                        if (p.WorkMinutes >= nextMins)
                                        {
                                            endTime = p.StartPoint.AddMinutes((double)nextMins);
                                            break;
                                        }
                                        nextMins -= p.WorkMinutes;
                                    }
                                }
                                remainTime -= needTime;
                            }
                            //记录生产周期
                            curSequences.Add(new PeriodSequenceDet
                            {
                                Domain = domain,
                                Line = lineStart.Line,
                                ItemNum = item.ItemNum,
                                PlanDate = beginTime.Date,
                                Period = dto.Period,
                                OrdQty = item.QtyOrded - item.QtyWorked,
                                WorkOrds = item.WorkOrd,
                                Op = item.Op,
                                IsActive = true,
                                Status = "",
                                CreateTime = DateTime.Now
                            });
                            //记录排产记录
                            curScheduleRsts.Add(new ScheduleResultOpMaster
                            {
                                Domain = domain,
                                WorkOrd = item.WorkOrd,
                                Line = lineStart.Line,
                                ItemNum = item.ItemNum,
                                Op = item.Op,
                                WorkDate = beginTime.Date,
                                WorkQty = item.QtyOrded - item.QtyWorked,
                                WorkStartTime = beginTime,
                                WorkEndTime = endTime,
                                CreateTime = DateTime.Now
                            });
                            //下一工单开始时间=当前工单结束时间，如果位于工作区间结尾，则为下一工作区间开始时间
                            curPoint = workPoints.FirstOrDefault(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                            //结束时间位于工作区间结尾
                            if (curPoint != null && endTime == curPoint.EndPoint)
                            {
                                //获取后续生产时间段
                                curPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                //存在后续工作区间
                                if (curPoint != null)
                                {
                                    endTime = curPoint.StartPoint;
                                }
                            }
                            beginTime = endTime;
                            //工单排产完成，排产时长=工单工作时长
                            item.Worked = item.LbrVar;
                            item.QtyWorked = item.QtyOrded;
                        }
                        //当天产能完全占用,且最后一个工单的清场时间刚好下班或者在下班后
                        if (endTime >= dto.EndTime)
                        {
                            sumTsTimes = 0;//排产完毕，特殊工单时长置0
                            //获取下一个工作日
                            workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                            isFstDay = true;
                            //特殊工单排产完成，占用了当天的全部产能，则需要判断下一个工作日是否存在特殊工单，如果存在，则需要继续排特殊工单
                            secWOMasters = tsWorkOrds.Where(p => p.ProdLine == lineStart.Line && p.OrdDate.Value.Date == workStartTime.Date).OrderBy(p => p.Priority).ToList();
                            //记录新增待排产特殊工单
                            if (secWOMasters.Any())
                            {
                                sumCleanTimes = 0m;
                                //新增特殊工单最后一个清场时长(分钟)
                                secCleanTime = 0m;
                                //生产时长
                                decimal sumLbrVar = 0m;
                                foreach (var item in secWOMasters)
                                {
                                    var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
                                    //剩余排产数量
                                    decimal qtyNeed = item.QtyOrded - curOp.QtyComplete;
                                    //剩余工作时长(分钟)
                                    decimal usedTime = Math.Ceiling(qtyNeed / item.QtyOrded * item.LbrVar * 60);
                                    workDtos.Add(new WorkOrdMstDto
                                    {
                                        WorkOrd = item.WorkOrd,
                                        ItemNum = item.ItemNum,
                                        QtyOrded = qtyNeed,
                                        LbrVar = usedTime,
                                        Worked = 0,
                                        QtyWorked = 0,
                                        Op = curOp.OP,
                                        WaitTime = curOp.WaitTime * 60,
                                        Priority = item.Priority
                                    });
                                    sumCleanTimes += curOp.WaitTime * 60;
                                    sumLbrVar += usedTime;
                                }
                                //获取最后一个特殊工单的清场时长
                                var last = secWOMasters.Last();
                                secCleanTime = tsWoRoutings.Where(p => p.WorkOrd == last.WorkOrd).OrderByDescending(p => p.OP).First().WaitTime * 60;
                                //特殊工单待排产时长=前一天特殊工单到最后一个清场时长+新增的特殊工单生产时长+新增特殊工单除最后一个清场时长之外的清场时长之和
                                sumTsTimes += (lstCleanTime + sumLbrVar + sumCleanTimes - secCleanTime);
                                lstCleanTime = secCleanTime;
                            }
                        }
                        //当天可用生产时长大于特殊工单生产时长+最后一个工单的清场时长
                        else
                        {
                            //排产完毕，特殊工单时长置0
                            sumTsTimes = 0;
                            //处理workStartTime
                            workStartTime = endTime;
                        }
                    }
                    //当天的可用产能不满足特殊工单生产时长,则当天产能全部排特殊工单(至少最后一个特殊工单的生产时长不能满足)
                    else
                    {
                        decimal residueTime = dto.EffTime;//当天产能剩余产能(分钟)
                        DateTime beginTime = workStartTime;//排产开始时间
                        DateTime endTime = dto.EndTime;//排产结束时间
                        foreach (var item in workDtos)
                        {
                            if (item.LbrVar == item.Worked)//当前工单已排产
                            {
                                continue;
                            }
                            //当前工单剩余待排产时长(分钟)
                            decimal needTime = item.LbrVar - item.Worked;
                            //当天剩余产能满足当前工单的剩余待排产时长(则当前工单的清场时间必定排完)
                            if (residueTime >= needTime)
                            {
                                //计算工单排产结束时间
                                var curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                span = curPoint.EndPoint - beginTime;
                                //当前工作时间段的有效生产时间(分钟)
                                decimal effMins = (decimal)span.TotalMinutes;
                                if (effMins >= needTime)//当前工作时间段即可满足产能
                                {
                                    endTime = beginTime.AddMinutes((double)needTime);
                                }
                                else
                                {
                                    //获取后续生产时间段
                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                    //剩余需要工作时长
                                    decimal nextMins = needTime - effMins;
                                    foreach (var p in nextPoints)
                                    {
                                        if (p.WorkMinutes >= nextMins)
                                        {
                                            endTime = p.StartPoint.AddMinutes((double)nextMins);
                                            break;
                                        }
                                        nextMins -= p.WorkMinutes;
                                    }
                                }
                                //当天剩余可用生产时长
                                residueTime -= needTime;
                                //处理清场时间，两种场景：
                                //1、residueTime<=item.WaitTime,结束时间加上剩余清场时长
                                if (residueTime <= item.WaitTime)
                                {
                                    //仍需排产的清场时长
                                    decimal otherTime = item.WaitTime - residueTime;
                                    endTime = dto.EndTime.AddMinutes((double)otherTime);
                                    residueTime = 0;
                                }
                                //2、residueTime>item.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                else
                                {
                                    //清场时长
                                    needTime = item.WaitTime;
                                    //获取工单排产结束时间所处时间段
                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                    span = curPoint.EndPoint - endTime;
                                    //当前工作时间段的有效生产时间(分钟)
                                    effMins = (decimal)span.TotalMinutes;
                                    //当前工作时间段即可清场时长
                                    if (effMins >= needTime)
                                    {
                                        endTime = endTime.AddMinutes((double)needTime);
                                    }
                                    else
                                    {
                                        //获取后续生产时间段
                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                        //剩余需要工作时长
                                        decimal nextMins = needTime - effMins;
                                        foreach (var p in nextPoints)
                                        {
                                            if (p.WorkMinutes >= nextMins)
                                            {
                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                break;
                                            }
                                            nextMins -= p.WorkMinutes;
                                        }
                                    }
                                    residueTime -= needTime;
                                }
                                //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);

                                //记录生产周期
                                curSequences.Add(new PeriodSequenceDet
                                {
                                    Domain = domain,
                                    Line = lineStart.Line,
                                    ItemNum = item.ItemNum,
                                    PlanDate = beginTime.Date,
                                    Period = dto.Period,
                                    OrdQty = item.QtyOrded - item.QtyWorked,
                                    WorkOrds = item.WorkOrd,
                                    Op = item.Op,
                                    IsActive = true,
                                    Status = "",
                                    CreateTime = DateTime.Now
                                });
                                //记录排产记录
                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                {
                                    Domain = domain,
                                    WorkOrd = item.WorkOrd,
                                    Line = lineStart.Line,
                                    ItemNum = item.ItemNum,
                                    Op = item.Op,
                                    WorkDate = beginTime.Date,
                                    WorkQty = item.QtyOrded - item.QtyWorked,
                                    WorkStartTime = beginTime,
                                    WorkEndTime = endTime,
                                    CreateTime = DateTime.Now
                                });
                                //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                item.Worked = item.LbrVar;
                                item.QtyWorked = item.QtyOrded;

                                beginTime = endTime;
                                //当天可用生产时长还有剩余
                                if (residueTime > 0)
                                {
                                    //获取结束时间所处时间段
                                    curPoint = workPoints.FirstOrDefault(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                    if (endTime == curPoint.EndPoint)
                                    {
                                        var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                        endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                    }
                                    beginTime = endTime;
                                }
                                //当天可用产能已全部用完
                                else {
                                    break;
                                }
                            }
                            //当天剩余产能不满足当前工单的剩余待排产时长
                            else
                            {
                                //计算生产数量
                                decimal qty = Math.Ceiling(residueTime / item.LbrVar * item.QtyOrded);
                                //记录生产周期
                                curSequences.Add(new PeriodSequenceDet
                                {
                                    Domain = domain,
                                    Line = lineStart.Line,
                                    ItemNum = item.ItemNum,
                                    PlanDate = beginTime.Date,
                                    Period = dto.Period,
                                    OrdQty = qty,
                                    WorkOrds = item.WorkOrd,
                                    Op = item.Op,
                                    IsActive = true,
                                    Status = "",
                                    CreateTime = DateTime.Now
                                });
                                //记录排产记录
                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                {
                                    Domain = domain,
                                    WorkOrd = item.WorkOrd,
                                    Line = lineStart.Line,
                                    ItemNum = item.ItemNum,
                                    Op = item.Op,
                                    WorkDate = beginTime.Date,
                                    WorkQty = qty,
                                    WorkStartTime = beginTime,
                                    WorkEndTime = endTime,
                                    CreateTime = DateTime.Now
                                });
                                item.Worked += residueTime;
                                item.QtyWorked += qty;
                                //特殊工单剩余待排产时长(分钟)
                                sumTsTimes -= residueTime;
                                residueTime = 0;
                                break;
                            }
                        }
                        //获取下一个工作日
                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                        isFstDay = false;
                    }
                }
                //记录已排产特殊工单
                ypcWorkOrds.AddRange(workDtos.Select(p => p.WorkOrd).ToList());

                //正常工单排产
                //正常工单产线已排产数量
                decimal sumQty = 0m;
                //产线准备时间(分钟)
                decimal sumTimes = 0m;
                fstWOMasters.Clear();
                workDtos.Clear();
                sumTsTimes = 0m;
                lstCleanTime = 0m;
                //工单排产第一天标识
                isFstDay = true;
                //前一天是否有特殊工单未排产完全
                bool isFullPC = true;
                while (sumQty < lineStart.QtyRemain || sumTsTimes > 0)
                {
                    secWOMasters.Clear();
                    sumCleanTimes = 0m;
                    secCleanTime = 0m;
                    //获取当天的产能
                    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 (!isFstDay)
                    {
                        //获取特殊工单
                        secWOMasters = tsWorkOrds.Where(p => p.ProdLine == lineStart.Line && p.OrdDate.Value.Date == workStartTime.Date).OrderBy(p => p.Priority).ToList();
                        if (secWOMasters.Any())
                        {
                            //生产时长
                            decimal sumLbrVar = 0m;
                            foreach (var item in secWOMasters)
                            {
                                var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
                                //剩余排产数量
                                decimal qtyNeed = item.QtyOrded - curOp.QtyComplete;
                                //剩余工作时长(分钟)
                                decimal usedTime = Math.Ceiling(qtyNeed / item.QtyOrded * item.LbrVar * 60);
                                workDtos.Add(new WorkOrdMstDto
                                {
                                    WorkOrd = item.WorkOrd,
                                    ItemNum = item.ItemNum,
                                    QtyOrded = qtyNeed,
                                    LbrVar = usedTime,
                                    Worked = 0,
                                    QtyWorked = 0,
                                    Op = curOp.OP,
                                    WaitTime = curOp.WaitTime * 60,
                                    Priority = item.Priority
                                });
                                sumLbrVar += usedTime;
                                sumCleanTimes += curOp.WaitTime * 60;
                            }
                            //获取最后一个特殊工单的清场时长
                            var last = secWOMasters.Last();
                            secCleanTime = tsWoRoutings.Where(p => p.WorkOrd == last.WorkOrd).OrderByDescending(p => p.OP).First().WaitTime * 60;
                            //特殊工单待排产时长=前一天特殊工单到最后一个清场时长+新增的特殊工单生产时长+新增特殊工单除最后一个清场时长之外的清场时长之和
                            sumTsTimes += (lstCleanTime + sumLbrVar + sumCleanTimes - secCleanTime);
                            lstCleanTime = secCleanTime;
                        }
                    }
                    //排产开始时，需要先减去产线准备时间(产线提前期满足的当天排产)
                    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.Floor(dto.Rate * residueTime / 60);
                            //已排产数量+当天的剩余产能小于工单剩余需排产数量,当天的产能需要全部排产
                            if (sumQty + sumAmount < lineStart.QtyRemain)
                            {
                                //当天有特殊工单,且当天的产能不能满足工单剩余需排产数量,则优先排特殊工单
                                if (sumTsTimes > 0)
                                {
                                    //特殊工单排序
                                    workDtos = workDtos.OrderBy(p => p.Priority).ToList();
                                    DateTime beginTime = workStartTime;//排产开始时间
                                    DateTime endTime = dto.EndTime;//排产结束时间
                                    //当天的可用生产时长满足特殊工单生产时长+清场时长(最后一个特殊工单的清场时长除外)
                                    if (residueTime >= sumTsTimes)
                                    {
                                        //获取最后一个工单
                                        var lastWork = workDtos.Last();
                                        //开始或结束时间所处时间段
                                        var curPoint = new LineWorkPointDto();
                                        //特殊工单排产
                                        foreach (var item in workDtos)
                                        {
                                            //当前工单已排产,跳过
                                            if (item.LbrVar == item.Worked)
                                            {
                                                continue;
                                            }
                                            //当前工单排产需要时长
                                            decimal needTime = 0m;
                                            //最后一个特殊工单
                                            if (item.WorkOrd == lastWork.WorkOrd)
                                            {
                                                //最后一个工单的生产时长+清场时长
                                                needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                                //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长,需要过滤掉休息时间
                                                if (residueTime >= needTime)
                                                {
                                                    //计算工单排产结束时间
                                                    curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                    //获取排产结束时间所处以及之后的生产时间段
                                                    var nextPoints = workPoints.Where(p => p.Level >= curPoint.Level).OrderBy(p => p.Level).ToList();
                                                    //处理第一个时间段的开始时间
                                                    nextPoints[0].StartPoint = beginTime;
                                                    foreach (var p in nextPoints)
                                                    {
                                                        span = p.EndPoint - p.StartPoint;
                                                        //当前工作时间段的有效生产时间
                                                        decimal effMins = (decimal)span.TotalMinutes;
                                                        if (effMins >= needTime)
                                                        {
                                                            endTime = p.StartPoint.AddMinutes((double)needTime);
                                                            break;
                                                        }
                                                        needTime -= effMins;
                                                        residueTime -= effMins;
                                                    }
                                                    //剩余可用生产时长
                                                    residueTime -= needTime;
                                                }
                                                //剩余可用工作时长不能满足清场时长
                                                else
                                                {
                                                    //还需排产的清场时间
                                                    decimal qcTime = needTime - residueTime;
                                                    endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                    residueTime = 0;
                                                }
                                            }
                                            //最后一个特殊工单之前的工单：剩余排产时长和清场时间全部排产
                                            else
                                            {
                                                //当前工单还需工作时长+清场时长
                                                needTime = item.LbrVar - item.Worked + item.WaitTime;
                                                //计算工单排产结束时间
                                                curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                span = curPoint.EndPoint - beginTime;
                                                //当天工作时间段的有效生产时间(分钟)
                                                decimal effMins = (decimal)span.TotalMinutes;
                                                //当前工作时间段即可满足产能
                                                if (effMins >= needTime)
                                                {
                                                    endTime = beginTime.AddMinutes((double)needTime);
                                                }
                                                else
                                                {
                                                    //获取后续生产时间段
                                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                    //剩余需要工作时长
                                                    decimal nextMins = needTime - effMins;
                                                    foreach (var p in nextPoints)
                                                    {
                                                        if (p.WorkMinutes >= nextMins)
                                                        {
                                                            endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                            break;
                                                        }
                                                        nextMins -= p.WorkMinutes;
                                                    }
                                                }
                                                residueTime -= needTime;
                                            }
                                            
                                            //记录生产周期
                                            curSequences.Add(new PeriodSequenceDet
                                            {
                                                Domain = domain,
                                                Line = lineStart.Line,
                                                ItemNum = item.ItemNum,
                                                PlanDate = beginTime.Date,
                                                Period = dto.Period,
                                                OrdQty = item.QtyOrded - item.QtyWorked,
                                                WorkOrds = item.WorkOrd,
                                                Op = item.Op,
                                                IsActive = true,
                                                Status = "",
                                                CreateTime = DateTime.Now
                                            });
                                            //记录排产记录
                                            curScheduleRsts.Add(new ScheduleResultOpMaster
                                            {
                                                Domain = domain,
                                                WorkOrd = item.WorkOrd,
                                                Line = lineStart.Line,
                                                ItemNum = item.ItemNum,
                                                Op = item.Op,
                                                WorkDate = beginTime.Date,
                                                WorkQty = item.QtyOrded - item.QtyWorked,
                                                WorkStartTime = beginTime,
                                                WorkEndTime = endTime,
                                                CreateTime = DateTime.Now
                                            });
                                            //下一工单开始时间=当前工单结束时间，如果位于工作区间结尾，则为下一工作区间开始时间
                                            curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                            //结束时间位于工作区间结尾
                                            if (curPoint != null && endTime == curPoint.EndPoint)
                                            {
                                                //获取后续生产时间段
                                                curPoint = workPoints.Where(p => p.Level == curPoint.Level + 1).FirstOrDefault();
                                                //存在后续工作区间
                                                if (curPoint != null)
                                                {
                                                    endTime = curPoint.StartPoint;
                                                }
                                            }
                                            beginTime = endTime;
                                            //工单排产完成，排产时长=工单工作时长
                                            item.Worked = item.LbrVar;
                                            item.QtyWorked = item.QtyOrded;
                                        }

                                        //剩余生产时长大于0，继续排正常工单(剩余产能<工单剩余待排产数量，当天不需要考虑该工单的清场时间)
                                        if (residueTime >0)
                                        {
                                            //处理正常工单开工时间
                                            workStartTime = endTime;
                                            //剩余产能继续排正常工单
                                            sumAmount = Math.Floor(dto.Rate * residueTime / 60);
                                            //记录生产周期
                                            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 = workStartTime,
                                                WorkEndTime = dto.EndTime,
                                                CreateTime = DateTime.Now
                                            });
                                            //累计已排产数量
                                            sumQty += sumAmount;
                                        }
                                        //继续排下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                        //排产完毕，特殊工单时长置0
                                        sumTsTimes = 0;
                                        isFullPC = true;
                                        //最后一个工单的清场时长
                                        lstCleanTime = 0m;
                                    }
                                    //当天的可用产能不满足特殊工单生产时长(最后一个工单的生产时长必定不满足)
                                    else
                                    {
                                        foreach (var item in workDtos)
                                        {
                                            if (item.LbrVar == item.Worked)//当前工单已排产
                                            {
                                                continue;
                                            }
                                            //当前工单剩余待排产时长(分钟)
                                            decimal needTime = item.LbrVar - item.Worked;
                                            //当天剩余产能满足当前工单的剩余待排产时长,则当前工单的清场时长必定排完
                                            if (residueTime >= needTime)
                                            {
                                                //计算工单排产结束时间
                                                var curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                span = curPoint.EndPoint - beginTime;
                                                //当前工作时间段的有效生产时间(分钟)
                                                decimal effMins = (decimal)span.TotalMinutes;
                                                //当前工作时间段即可满足产能
                                                if (effMins >= needTime)
                                                {
                                                    endTime = beginTime.AddMinutes((double)needTime);
                                                }
                                                else
                                                {
                                                    //获取后续生产时间段
                                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                    //剩余需要工作时长
                                                    decimal nextMins = needTime - effMins;
                                                    foreach (var p in nextPoints)
                                                    {
                                                        if (p.WorkMinutes >= nextMins)
                                                        {
                                                            endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                            break;
                                                        }
                                                        nextMins -= p.WorkMinutes;
                                                    }
                                                }

                                                //当天剩余可用生产时长
                                                residueTime -= needTime;
                                                //处理清场时间，两种场景：
                                                //1、residueTime<=item.WaitTime,结束时间加上剩余清场时长
                                                if (residueTime <= item.WaitTime)
                                                {
                                                    //仍需排产的清场时长
                                                    decimal otherTime = item.WaitTime - residueTime;
                                                    endTime = dto.EndTime.AddMinutes((double)otherTime);
                                                    residueTime = 0;
                                                }
                                                //2、residueTime>item.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                                else
                                                {
                                                    //清场时长
                                                    needTime = item.WaitTime;
                                                    //获取工单排产结束时间所处时间段
                                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                    span = curPoint.EndPoint - endTime;
                                                    //当前工作时间段的有效生产时间(分钟)
                                                    effMins = (decimal)span.TotalMinutes;
                                                    //当前工作时间段即可清场时长
                                                    if (effMins >= needTime)
                                                    {
                                                        endTime = endTime.AddMinutes((double)needTime);
                                                    }
                                                    else
                                                    {
                                                        //获取后续生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //剩余需要工作时长
                                                        decimal nextMins = needTime - effMins;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            if (p.WorkMinutes >= nextMins)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                break;
                                                            }
                                                            nextMins -= p.WorkMinutes;
                                                        }
                                                    }
                                                    //剩余生产时长
                                                    residueTime -= needTime;
                                                }
                                                //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                                sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);
                                                //记录生产周期
                                                curSequences.Add(new PeriodSequenceDet
                                                {
                                                    Domain = domain,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    PlanDate = beginTime.Date,
                                                    Period = dto.Period,
                                                    OrdQty = item.QtyOrded - item.QtyWorked,
                                                    WorkOrds = item.WorkOrd,
                                                    Op = item.Op,
                                                    IsActive = true,
                                                    Status = "",
                                                    CreateTime = DateTime.Now
                                                });
                                                //记录排产记录
                                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                                {
                                                    Domain = domain,
                                                    WorkOrd = item.WorkOrd,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    Op = item.Op,
                                                    WorkDate = beginTime.Date,
                                                    WorkQty = item.QtyOrded - item.QtyWorked,
                                                    WorkStartTime = beginTime,
                                                    WorkEndTime = endTime,
                                                    CreateTime = DateTime.Now
                                                });
                                                //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                item.Worked = item.LbrVar;
                                                item.QtyWorked = item.QtyOrded;

                                                beginTime = endTime;
                                                //当天可用生产时长还有剩余
                                                if (residueTime > 0)
                                                {
                                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                    if (endTime == curPoint.EndPoint)
                                                    {
                                                        var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                        endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                                    }
                                                    beginTime = endTime;
                                                }
                                                //当天剩余产能排完
                                                else {
                                                    break;
                                                }
                                            }
                                            //当天剩余产能不满足当前工单的剩余待排产时长
                                            else
                                            {
                                                //计算生产数量
                                                decimal qty = Math.Ceiling(residueTime / item.LbrVar * item.QtyOrded);
                                                //记录生产周期
                                                curSequences.Add(new PeriodSequenceDet
                                                {
                                                    Domain = domain,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    PlanDate = beginTime.Date,
                                                    Period = dto.Period,
                                                    OrdQty = qty,
                                                    WorkOrds = item.WorkOrd,
                                                    Op = item.Op,
                                                    IsActive = true,
                                                    Status = "",
                                                    CreateTime = DateTime.Now
                                                });
                                                //记录排产记录
                                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                                {
                                                    Domain = domain,
                                                    WorkOrd = item.WorkOrd,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    Op = item.Op,
                                                    WorkDate = beginTime.Date,
                                                    WorkQty = qty,
                                                    WorkStartTime = beginTime,
                                                    WorkEndTime = dto.EndTime,
                                                    CreateTime = DateTime.Now
                                                });
                                                item.Worked += residueTime;
                                                item.QtyWorked += qty;
                                                //特殊工单剩余待排产时长(分钟)
                                                sumTsTimes -= residueTime;
                                                residueTime = 0m;
                                                break;
                                            }
                                        }
                                        //当天产能不能满足特殊工单排产
                                        isFullPC = false;
                                        //获取下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                    }
                                }
                                //当天没有特殊工单,直接进行正常工单排产(当天产能<工单剩余待排产数量，当天不需要考虑该工单的清场时间)
                                else
                                { 
                                    //记录生产周期
                                    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);
                                    isFstDay = false;
                                }
                            }
                            //当天的剩余产能可满足正常工单剩余待排产数量,则先排正常工单，需要考虑清场时间，如果有特殊工单，则后排
                            else
                            {
                                #region 正常工单排产-开始
                                //剩余需要排产的数量
                                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);
                                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
                                });
                                #endregion 正常工单排产-结束

                                //当天排完正常工单后的剩余生产时长(分钟)
                                decimal restTime = residueTime < 0 ? 0 : residueTime;
                                //当天存在特殊工单
                                if (sumTsTimes > 0)
                                {
                                    workDtos = workDtos.OrderBy(p => p.Priority).ToList();
                                    //当天剩余生产时长大于0，特殊工单排产
                                    if (restTime > 0)
                                    {
                                        //处理正常工单排产结束时间<=>特殊工单排产开始时间
                                        curPoint = workPoints.Find(p => p.StartPoint <= workEndTime && workEndTime <= p.EndPoint);
                                        if (workEndTime == curPoint.EndPoint)
                                        {
                                            var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                            if (nextPoint != null)
                                            {
                                                workEndTime = nextPoint.StartPoint;
                                            }
                                        }
                                        #region 特殊工单排产-开始
                                        DateTime beginTime = workEndTime;//排产开始时间
                                        DateTime endTime = dto.EndTime;//排产结束时间
                                        //当天的剩余生产时长满足特殊工单生产时长+清场时长(最后一个工单清场时长除外)
                                        if (restTime >= sumTsTimes)
                                        {
                                            //获取最后一个工单
                                            var lastWork = workDtos.Last();
                                            //特殊工单排产
                                            foreach (var item in workDtos)
                                            {
                                                if (item.LbrVar == item.Worked)//当前工单已排产
                                                {
                                                    continue;
                                                }
                                                //当前工单还需工作时长
                                                decimal needTime = 0m;
                                                //最后一个特殊工单
                                                if (item.WorkOrd == lastWork.WorkOrd)
                                                {
                                                    //最后一个工单的生产时长+清场时长
                                                    needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                                    //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                                    if (restTime >= needTime)
                                                    {
                                                        //计算工单排产结束时间
                                                        curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                        //获取排产结束时间所处以及之后的生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level >= curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //处理第一个时间段的开始时间
                                                        nextPoints[0].StartPoint = beginTime;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            span = p.EndPoint - p.StartPoint;
                                                            //当前工作时间段的有效生产时间
                                                            effMins = (decimal)span.TotalMinutes;
                                                            if (effMins >= needTime)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)needTime);
                                                                break;
                                                            }
                                                            needTime -= effMins;
                                                            restTime -= effMins;
                                                        }
                                                        restTime -= needTime;
                                                    }
                                                    //剩余可用工作时长不能满足清场时长
                                                    else
                                                    {
                                                        //还需排产的清场时间
                                                        decimal qcTime = needTime - restTime;
                                                        endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                        restTime = 0;
                                                    }
                                                    //最后一个工单的清场时长
                                                    lstCleanTime = 0m;
                                                }
                                                //最后一个特殊工单之前的工单：剩余排产时长和清场时间全部排产
                                                else
                                                {
                                                    needTime = item.LbrVar - item.Worked + item.WaitTime;
                                                    //计算工单排产结束时间
                                                    curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                    span = curPoint.EndPoint - beginTime;
                                                    //当天工作时间段的有效生产时间(分钟)
                                                    effMins = (decimal)span.TotalMinutes;
                                                    //当前工作时间段即可满足产能
                                                    if (effMins >= needTime)
                                                    {
                                                        endTime = beginTime.AddMinutes((double)needTime);
                                                    }
                                                    else
                                                    {
                                                        //获取后续生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //剩余需要工作时长
                                                        decimal nextMins = needTime - effMins;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            if (p.WorkMinutes >= nextMins)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                break;
                                                            }
                                                            nextMins -= p.WorkMinutes;
                                                        }
                                                    }
                                                    restTime -= needTime;
                                                }
                                                
                                                //记录生产周期
                                                curSequences.Add(new PeriodSequenceDet
                                                {
                                                    Domain = domain,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    PlanDate = beginTime.Date,
                                                    Period = dto.Period,
                                                    OrdQty = item.QtyOrded - item.QtyWorked,
                                                    WorkOrds = item.WorkOrd,
                                                    Op = item.Op,
                                                    IsActive = true,
                                                    Status = "",
                                                    CreateTime = DateTime.Now
                                                });
                                                //记录排产记录
                                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                                {
                                                    Domain = domain,
                                                    WorkOrd = item.WorkOrd,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    Op = item.Op,
                                                    WorkDate = beginTime.Date,
                                                    WorkQty = item.QtyOrded - item.QtyWorked,
                                                    WorkStartTime = beginTime,
                                                    WorkEndTime = endTime,
                                                    CreateTime = DateTime.Now
                                                });
                                                //下一工单开始时间=当前工单结束时间，如果位于工作区间结尾，则为下一工作区间开始时间
                                                curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                //结束时间位于工作区间结尾
                                                if (curPoint != null && endTime == curPoint.EndPoint)
                                                {
                                                    //获取后续生产时间段
                                                    curPoint = workPoints.Where(p => p.Level == curPoint.Level + 1).FirstOrDefault();
                                                    if (curPoint != null)//存在后续工作区间
                                                    {
                                                        endTime = curPoint.StartPoint;
                                                    }
                                                }
                                                beginTime = endTime;
                                                //工单排产完成，排产时长=工单工作时长
                                                item.Worked = item.LbrVar;
                                                item.QtyWorked = item.QtyOrded;
                                            }
                                            sumTsTimes = 0;//排产完毕，特殊工单时长置0
                                            isFullPC = true;
                                        }
                                        //当天的剩余生产时长不满足特殊工单生产时长(至少最后一个特殊工单的生产时长不能满足)
                                        else
                                        {
                                            foreach (var item in workDtos)
                                            {
                                                if (item.LbrVar == item.Worked)//当前工单已排产
                                                {
                                                    continue;
                                                }
                                                //当前工单剩余待排产时长(分钟)
                                                decimal needTime = item.LbrVar - item.Worked;
                                                //当天剩余产能满足当前工单的剩余待排产时长(则当前工单的清场时长必定满足)
                                                if (restTime >= needTime)
                                                {
                                                    //计算工单排产结束时间
                                                    curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                    span = curPoint.EndPoint - beginTime;
                                                    //当前工作时间段的有效生产时间(分钟)
                                                    effMins = (decimal)span.TotalMinutes;
                                                    //当前工作时间段即可满足产能
                                                    if (effMins >= needTime)
                                                    {
                                                        endTime = beginTime.AddMinutes((double)needTime);
                                                    }
                                                    else
                                                    {
                                                        //获取后续生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //剩余需要工作时长
                                                        decimal nextMins = needTime - effMins;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            if (p.WorkMinutes >= nextMins)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                break;
                                                            }
                                                            nextMins -= p.WorkMinutes;
                                                        }
                                                    }
                                                    //当天剩余可用生产时长
                                                    restTime -= needTime;
                                                    //处理清场时间，两种场景：
                                                    //1、restTime<=item.WaitTime,结束时间加上剩余清场时长
                                                    if (restTime <= item.WaitTime)
                                                    {
                                                        //仍需排产的清场时长
                                                        decimal otherTime = item.WaitTime - restTime;
                                                        endTime = dto.EndTime.AddMinutes((double)otherTime);
                                                        restTime = 0;
                                                    }
                                                    //2、restTime>item.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                                    else
                                                    {
                                                        //清场时长
                                                        needTime = item.WaitTime;
                                                        //获取工单排产结束时间所处时间段
                                                        curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                        span = curPoint.EndPoint - endTime;
                                                        //当前工作时间段的有效生产时间(分钟)
                                                        effMins = (decimal)span.TotalMinutes;
                                                        //当前工作时间段即可清场时长
                                                        if (effMins >= needTime)
                                                        {
                                                            endTime = endTime.AddMinutes((double)needTime);
                                                        }
                                                        else
                                                        {
                                                            //获取后续生产时间段
                                                            var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                            //剩余需要工作时长
                                                            decimal nextMins = needTime - effMins;
                                                            foreach (var p in nextPoints)
                                                            {
                                                                if (p.WorkMinutes >= nextMins)
                                                                {
                                                                    endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                    break;
                                                                }
                                                                nextMins -= p.WorkMinutes;
                                                            }
                                                        }
                                                        restTime -= needTime;
                                                    }
                                                    //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                                    sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);

                                                    //记录生产周期
                                                    curSequences.Add(new PeriodSequenceDet
                                                    {
                                                        Domain = domain,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        PlanDate = beginTime.Date,
                                                        Period = dto.Period,
                                                        OrdQty = item.QtyOrded - item.QtyWorked,
                                                        WorkOrds = item.WorkOrd,
                                                        Op = item.Op,
                                                        IsActive = true,
                                                        Status = "",
                                                        CreateTime = DateTime.Now
                                                    });
                                                    //记录排产记录
                                                    curScheduleRsts.Add(new ScheduleResultOpMaster
                                                    {
                                                        Domain = domain,
                                                        WorkOrd = item.WorkOrd,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        Op = item.Op,
                                                        WorkDate = beginTime.Date,
                                                        WorkQty = item.QtyOrded - item.QtyWorked,
                                                        WorkStartTime = beginTime,
                                                        WorkEndTime = endTime,
                                                        CreateTime = DateTime.Now
                                                    });
                                                    //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                    item.Worked = item.LbrVar;
                                                    item.QtyWorked = item.QtyOrded;

                                                    beginTime = endTime;
                                                    if (restTime > 0)
                                                    {
                                                        curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                        if (endTime == curPoint.EndPoint )
                                                        {
                                                            var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                            if (nextPoint != null)
                                                            {
                                                                endTime = nextPoint.StartPoint;
                                                            }
                                                            beginTime = endTime;
                                                        }
                                                    }
                                                    //当天产能已全部用完
                                                    else
                                                    {
                                                        break;
                                                    }
                                                }
                                                //当天剩余产能不满足当前工单的剩余待排产时长
                                                else
                                                {
                                                    //计算生产数量
                                                    decimal qty = Math.Ceiling(restTime / item.LbrVar * item.QtyOrded);
                                                    //记录生产周期
                                                    curSequences.Add(new PeriodSequenceDet
                                                    {
                                                        Domain = domain,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        PlanDate = beginTime.Date,
                                                        Period = dto.Period,
                                                        OrdQty = qty,
                                                        WorkOrds = item.WorkOrd,
                                                        Op = item.Op,
                                                        IsActive = true,
                                                        Status = "",
                                                        CreateTime = DateTime.Now
                                                    });
                                                    //记录排产记录
                                                    curScheduleRsts.Add(new ScheduleResultOpMaster
                                                    {
                                                        Domain = domain,
                                                        WorkOrd = item.WorkOrd,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        Op = item.Op,
                                                        WorkDate = beginTime.Date,
                                                        WorkQty = qty,
                                                        WorkStartTime = beginTime,
                                                        WorkEndTime = dto.EndTime,
                                                        CreateTime = DateTime.Now
                                                    });
                                                    item.Worked += restTime;
                                                    item.QtyWorked += qty;
                                                    //特殊工单剩余待排产时长(分钟)
                                                    sumTsTimes -= restTime;
                                                    restTime = 0m;
                                                    break;
                                                }
                                            }
                                            //获取下一个工作日
                                            workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                            isFstDay = false;
                                            //当天特殊工单未排产完全
                                            isFullPC = false;
                                        }
                                        #endregion 特殊工单排产-结束
                                    }
                                    //当天剩余生产时长为0,由于存在特殊工单，则循环下一个工作日进行排产
                                    else 
                                    {
                                        //继续排下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                        //当天特殊工单未排产完全
                                        isFullPC = false;
                                    }
                                }
                            }
                            //记录提前期
                            sumTimes = lineStart.setupTime * 60;
                        }
                        //当天可用生产时长不能满足或者刚好满足提前期
                        else
                        {
                            //当天的可用生产时长不能满足提前期
                            sumTimes += dto.EffTime;
                            //获取下一个工作日
                            workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                            isFstDay = false;
                        }
                    }
                    //产线提前期满足的下一个工作日排产
                    else
                    {
                        //如果前一天的特殊工单没排产完，则先排特殊工单,如果当天还安排有特殊工单，则将特殊工单提前
                        if (!isFullPC)
                        {
                            //当天可用生产时长(分钟)
                            decimal residueTime = dto.EffTime;
                            DateTime beginTime = workStartTime;//排产开始时间
                            DateTime endTime = dto.EndTime;//排产结束时间
                            workDtos = workDtos.OrderBy(p => p.Priority).ToList();
                            //当天的可用生产时长满足特殊工单生产时长+清场时长(最后一个工单清场时间除外)
                            if (residueTime >= sumTsTimes)
                            {
                                //获取最后一个工单
                                var lastWork = workDtos.Last();
                                //开始或结束时间所处时间段
                                var curPoint = new LineWorkPointDto();
                                //特殊工单排产
                                foreach (var item in workDtos)
                                {
                                    if (item.LbrVar == item.Worked)//当前工单已排产,跳过
                                    {
                                        continue;
                                    }
                                    //当前工单还需工作时长
                                    decimal needTime = 0m;
                                    //最后一个特殊工单
                                    if (item.WorkOrd == lastWork.WorkOrd)
                                    {
                                        //最后一个工单的生产时长+清场时长
                                        needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                        //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                        if (residueTime >= needTime)
                                        {
                                            //计算工单排产结束时间
                                            curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                            //获取排产结束时间所处以及之后的生产时间段
                                            var nextPoints = workPoints.Where(p => p.Level >= curPoint.Level).OrderBy(p => p.Level).ToList();
                                            //处理第一个时间段的开始时间
                                            nextPoints[0].StartPoint = beginTime;
                                            foreach (var p in nextPoints)
                                            {
                                                span = p.EndPoint - p.StartPoint;
                                                //当前工作时间段的有效生产时间
                                                decimal effMins = (decimal)span.TotalMinutes;
                                                if (effMins >= needTime)
                                                {
                                                    endTime = p.StartPoint.AddMinutes((double)needTime);
                                                    break;
                                                }
                                                needTime -= effMins;
                                                residueTime -= effMins;
                                            }
                                            residueTime -= needTime;
                                        }
                                        //剩余可用工作时长不能满足清场时长
                                        else
                                        {
                                            //还需排产的清场时间
                                            decimal qcTime = needTime - residueTime;
                                            endTime = dto.EndTime.AddMinutes((double)qcTime);
                                            residueTime = 0;
                                        }
                                        //最后一个工单的清场时长
                                        lstCleanTime = 0m;
                                        break;
                                    }
                                    //最后一个特殊工单之前的工单：剩余排产时长和清场时间全部排产
                                    else
                                    {
                                        //当前工单还需工作时长+清场时长
                                        needTime = item.LbrVar - item.Worked + item.WaitTime;
                                        //计算工单排产结束时间
                                        curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                        span = curPoint.EndPoint - beginTime;
                                        //当天工作时间段的有效生产时间(分钟)
                                        decimal effMins = (decimal)span.TotalMinutes;
                                        //当前工作时间段即可满足产能
                                        if (effMins >= needTime)
                                        {
                                            endTime = beginTime.AddMinutes((double)needTime);
                                        }
                                        else
                                        {
                                            //获取后续生产时间段
                                            var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                            //剩余需要工作时长
                                            decimal nextMins = needTime - effMins;
                                            foreach (var p in nextPoints)
                                            {
                                                if (p.WorkMinutes >= nextMins)
                                                {
                                                    endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                    break;
                                                }
                                                nextMins -= p.WorkMinutes;
                                            }
                                        }

                                        //剩余可用时长
                                        residueTime -= needTime;
                                    }

                                    //记录生产周期
                                    curSequences.Add(new PeriodSequenceDet
                                    {
                                        Domain = domain,
                                        Line = lineStart.Line,
                                        ItemNum = item.ItemNum,
                                        PlanDate = beginTime.Date,
                                        Period = dto.Period,
                                        OrdQty = item.QtyOrded - item.QtyWorked,
                                        WorkOrds = item.WorkOrd,
                                        Op = item.Op,
                                        IsActive = true,
                                        Status = "",
                                        CreateTime = DateTime.Now
                                    });
                                    //记录排产记录
                                    curScheduleRsts.Add(new ScheduleResultOpMaster
                                    {
                                        Domain = domain,
                                        WorkOrd = item.WorkOrd,
                                        Line = lineStart.Line,
                                        ItemNum = item.ItemNum,
                                        Op = item.Op,
                                        WorkDate = beginTime.Date,
                                        WorkQty = item.QtyOrded - item.QtyWorked,
                                        WorkStartTime = beginTime,
                                        WorkEndTime = endTime,
                                        CreateTime = DateTime.Now
                                    });
                                    //下一工单开始时间=当前工单结束时间，如果位于工作区间结尾，则为下一工作区间开始时间
                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                    //结束时间位于工作区间结尾
                                    if (curPoint != null && endTime == curPoint.EndPoint)
                                    {
                                        //获取后续生产时间段
                                        var nextPoint = workPoints.Where(p => p.Level == curPoint.Level + 1).FirstOrDefault();
                                        //存在后续工作区间
                                        if (nextPoint != null)
                                        {
                                            endTime = nextPoint.StartPoint;
                                        }
                                    }
                                    beginTime = endTime;
                                    //工单排产完成，排产时长=工单工作时长
                                    item.Worked = item.LbrVar;
                                    item.QtyWorked = item.QtyOrded;
                                }
                                //排产完毕，特殊工单时长置0
                                sumTsTimes = 0;
                                //当天特殊工单全部排产完成
                                isFullPC = true;
                                //特殊工单排产完成，最后一个工单的清场时长置0
                                lstCleanTime = 0m;

                                //剩余可用生产时长
                                residueTime = residueTime < 0 ? 0 : residueTime;
                                //特殊工单处理完成，剩余生产时长大于0且还有正常工单待排产，则继续排正常工单
                                if (residueTime > 0 && sumQty < lineStart.QtyRemain)
                                {
                                    workStartTime = beginTime;//排产开始时间
                                    //剩余产能继续排正常工单
                                    decimal sumAmount = Math.Floor(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 = workStartTime,
                                            WorkEndTime = dto.EndTime,
                                            CreateTime = DateTime.Now
                                        });
                                        //累计已排产数量
                                        sumQty += sumAmount;
                                        //继续排下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                    }
                                    //剩余产能满足正常工单待排产数量，此时需要排清场时长
                                    else
                                    {
                                        //剩余需要排产的数量
                                        decimal residueQty = lineStart.QtyRemain - sumQty;
                                        //剩余数量生产需要时长(分钟)
                                        decimal workTime = Math.Ceiling(residueQty / dto.Rate * 60);
                                        //处理剩余需要生产时长：防止向上取整导致超过residueTime
                                        workTime = workTime > residueTime ? residueTime : workTime;
                                        curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                        span = curPoint.EndPoint - workStartTime;
                                        //当天工作时间段的有效生产时间
                                        decimal effMins = (decimal)span.TotalMinutes;
                                        //当前工作时间段即可满足产能
                                        if (effMins >= workTime)
                                        {
                                            endTime = 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)
                                                {
                                                    endTime = 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;
                                            endTime = dto.EndTime.AddMinutes((double)otherTime);
                                            residueTime = 0;
                                        }
                                        //2、residueTime>lineStart.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                        else
                                        {
                                            //清场时长
                                            workTime = lineStart.WaitTime;
                                            //获取工单排产结束时间所处时间段
                                            curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                            span = curPoint.EndPoint - endTime;
                                            //当前工作时间段的有效生产时间(分钟)
                                            effMins = (decimal)span.TotalMinutes;
                                            //当前工作时间段即可清场时长
                                            if (effMins >= workTime)
                                            {
                                                endTime = endTime.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)
                                                    {
                                                        endTime = 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 = endTime,
                                            CreateTime = DateTime.Now
                                        });
                                    }
                                }
                                else {
                                    //获取下一个工作日
                                    workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                    isFstDay = false;
                                }
                            }
                            //当天的可用产能不满特殊工单生产时长,则当天产能全部排特殊工单(至少最后一个特殊工单的生产时长不能满足)
                            else
                            {
                                //特殊工单排产
                                foreach (var item in workDtos)
                                {
                                    if (item.LbrVar == item.Worked)//当前工单已排产
                                    {
                                        continue;
                                    }
                                    //当前工单剩余待排产时长(分钟)
                                    decimal needTime = item.LbrVar - item.Worked;
                                    //当天剩余产能满足当前工单的剩余待排产时长(则当前工单的清场时间必定排完)
                                    if (residueTime >= needTime)
                                    {
                                        //计算工单排产结束时间
                                        var curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                        span = curPoint.EndPoint - beginTime;
                                        //当前工作时间段的有效生产时间(分钟)
                                        decimal effMins = (decimal)span.TotalMinutes;
                                        //当前工作时间段即可满足产能
                                        if (effMins >= needTime)
                                        {
                                            endTime = beginTime.AddMinutes((double)needTime);
                                        }
                                        else
                                        {
                                            //获取后续生产时间段
                                            var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                            //剩余需要工作时长
                                            decimal nextMins = needTime - effMins;
                                            foreach (var p in nextPoints)
                                            {
                                                if (p.WorkMinutes >= nextMins)
                                                {
                                                    endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                    break;
                                                }
                                                nextMins -= p.WorkMinutes;
                                            }
                                        }

                                        //当天剩余可用生产时长
                                        residueTime -= needTime;
                                        //处理清场时间，两种场景：
                                        //1、residueTime<=item.WaitTime,结束时间加上剩余清场时长
                                        if (residueTime <= item.WaitTime)
                                        {
                                            //仍需排产的清场时长
                                            decimal otherTime = item.WaitTime - residueTime;
                                            endTime = dto.EndTime.AddMinutes((double)otherTime);
                                            residueTime = 0;
                                        }
                                        //2、residueTime>item.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                        else
                                        {
                                            //清场时长
                                            needTime = item.WaitTime;
                                            //获取工单排产结束时间所处时间段
                                            curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                            span = curPoint.EndPoint - endTime;
                                            //当前工作时间段的有效生产时间(分钟)
                                            effMins = (decimal)span.TotalMinutes;
                                            //当前工作时间段即可清场时长
                                            if (effMins >= needTime)
                                            {
                                                endTime = endTime.AddMinutes((double)needTime);
                                            }
                                            else
                                            {
                                                //获取后续生产时间段
                                                var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                //剩余需要工作时长
                                                decimal nextMins = needTime - effMins;
                                                foreach (var p in nextPoints)
                                                {
                                                    if (p.WorkMinutes >= nextMins)
                                                    {
                                                        endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                        break;
                                                    }
                                                    nextMins -= p.WorkMinutes;
                                                }
                                            }
                                            residueTime -= needTime;
                                        }
                                        //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                        sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);

                                        //记录生产周期
                                        curSequences.Add(new PeriodSequenceDet
                                        {
                                            Domain = domain,
                                            Line = lineStart.Line,
                                            ItemNum = item.ItemNum,
                                            PlanDate = beginTime.Date,
                                            Period = dto.Period,
                                            OrdQty = item.QtyOrded - item.QtyWorked,
                                            WorkOrds = item.WorkOrd,
                                            Op = item.Op,
                                            IsActive = true,
                                            Status = "",
                                            CreateTime = DateTime.Now
                                        });
                                        //记录排产记录
                                        curScheduleRsts.Add(new ScheduleResultOpMaster
                                        {
                                            Domain = domain,
                                            WorkOrd = item.WorkOrd,
                                            Line = lineStart.Line,
                                            ItemNum = item.ItemNum,
                                            Op = item.Op,
                                            WorkDate = beginTime.Date,
                                            WorkQty = item.QtyOrded - item.QtyWorked,
                                            WorkStartTime = beginTime,
                                            WorkEndTime = endTime,
                                            CreateTime = DateTime.Now
                                        });
                                        //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                        item.Worked = item.LbrVar;
                                        item.QtyWorked = item.QtyOrded;

                                        beginTime = endTime;
                                        //当天可用生产时长还有剩余
                                        if (residueTime > 0)
                                        {
                                            //获取结束时间所处时间段
                                            curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                            if (endTime == curPoint.EndPoint)
                                            {
                                                var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                            }
                                            beginTime = endTime;
                                        }
                                        //当天可用产能已全部用完
                                        else
                                        {
                                            break;
                                        }
                                    }
                                    //当天剩余产能不满足当前工单的剩余待排产时长
                                    else
                                    {
                                        //计算生产数量
                                        decimal qty = Math.Ceiling(residueTime / item.LbrVar * item.QtyOrded);
                                        //记录生产周期
                                        curSequences.Add(new PeriodSequenceDet
                                        {
                                            Domain = domain,
                                            Line = lineStart.Line,
                                            ItemNum = item.ItemNum,
                                            PlanDate = beginTime.Date,
                                            Period = dto.Period,
                                            OrdQty = qty,
                                            WorkOrds = item.WorkOrd,
                                            Op = item.Op,
                                            IsActive = true,
                                            Status = "",
                                            CreateTime = DateTime.Now
                                        });
                                        //记录排产记录
                                        curScheduleRsts.Add(new ScheduleResultOpMaster
                                        {
                                            Domain = domain,
                                            WorkOrd = item.WorkOrd,
                                            Line = lineStart.Line,
                                            ItemNum = item.ItemNum,
                                            Op = item.Op,
                                            WorkDate = beginTime.Date,
                                            WorkQty = qty,
                                            WorkStartTime = beginTime,
                                            WorkEndTime = dto.EndTime,
                                            CreateTime = DateTime.Now
                                        });
                                        item.Worked += residueTime;
                                        item.QtyWorked += qty;
                                        //特殊工单剩余待排产时长(分钟)
                                        sumTsTimes -= residueTime;
                                        residueTime = 0m;
                                        break;
                                    }
                                }
                                //当天特殊工单未排产完成
                                isFullPC = false;
                                //获取下一个工作日
                                workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                isFstDay = false;
                            }
                        }
                        //当天之前的特殊工单全部排产完毕
                        else {
                            //已排产数量+当天的产能小于工单数量，当天的产能需要全部排产
                            if (sumQty + dto.ProductQty < lineStart.QtyRemain)
                            {
                                //当天有特殊工单,先排特殊工单
                                if (sumTsTimes > 0)
                                {
                                    //当天剩余产能(分钟)
                                    decimal residueTime = dto.EffTime;
                                    DateTime beginTime = workStartTime;//排产开始时间
                                    DateTime endTime = dto.EndTime;//排产结束时间
                                    workDtos = workDtos.OrderBy(p => p.Priority).ToList();
                                    //当天的可用产能满足特殊工单生产时长+清场时长(最后一个工单清场时间除外)
                                    if (residueTime >= sumTsTimes)
                                    {
                                        var lastWork = workDtos.Last();
                                        //开始或结束时间所处时间段
                                        var curPoint = new LineWorkPointDto();
                                        //特殊工单排产
                                        foreach (var item in workDtos)
                                        {
                                            if (item.LbrVar == item.Worked)//当前工单已排产
                                            {
                                                continue;
                                            }
                                            //当前工单排产需要时长
                                            decimal needTime = 0m;
                                            //最后一个特殊工单
                                            if (item.WorkOrd == lastWork.WorkOrd) 
                                            {
                                                //最后一个工单的生产时长+清场时长
                                                needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                                //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                                if (residueTime >= needTime)
                                                {
                                                    //计算工单排产结束时间
                                                    curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                    //获取排产结束时间所处以及之后的生产时间段
                                                    var nextPoints = workPoints.Where(p => p.Level >= curPoint.Level).OrderBy(p => p.Level).ToList();
                                                    //处理第一个时间段的开始时间
                                                    nextPoints[0].StartPoint = beginTime;
                                                    foreach (var p in nextPoints)
                                                    {
                                                        span = p.EndPoint - p.StartPoint;
                                                        //当前工作时间段的有效生产时间
                                                        decimal effMins = (decimal)span.TotalMinutes;
                                                        if (effMins >= needTime)
                                                        {
                                                            endTime = p.StartPoint.AddMinutes((double)needTime);
                                                            break;
                                                        }
                                                        needTime -= effMins;
                                                        residueTime -= effMins;
                                                    }
                                                    residueTime -= needTime;
                                                }
                                                //剩余可用工作时长不能满足清场时长
                                                else
                                                {
                                                    //还需排产的清场时间
                                                    decimal qcTime = needTime - residueTime;
                                                    endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                    residueTime = 0;
                                                }
                                                //最后一个工单的清场时长
                                                lstCleanTime = 0m;
                                            }
                                            //最后一个特殊工单之前的工单：剩余排产时长和清场时间全部排产
                                            else
                                            {
                                                //当前工单还需工作时长+工单的清场时长
                                                needTime = item.LbrVar - item.Worked + item.WaitTime;
                                                //计算工单排产结束时间
                                                curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                span = curPoint.EndPoint - beginTime;
                                                //当天工作时间段的有效生产时间(分钟)
                                                decimal effMins = (decimal)span.TotalMinutes;
                                                if (effMins >= needTime)//当前工作时间段即可满足产能
                                                {
                                                    endTime = beginTime.AddMinutes((double)needTime);
                                                }
                                                else
                                                {
                                                    //获取后续生产时间段
                                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                    //剩余需要工作时长
                                                    decimal nextMins = needTime - effMins;
                                                    foreach (var p in nextPoints)
                                                    {
                                                        if (p.WorkMinutes >= nextMins)
                                                        {
                                                            endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                            break;
                                                        }
                                                        nextMins -= p.WorkMinutes;
                                                    }
                                                }
                                                residueTime -= needTime;
                                            }
                                            
                                            //记录生产周期
                                            curSequences.Add(new PeriodSequenceDet
                                            {
                                                Domain = domain,
                                                Line = lineStart.Line,
                                                ItemNum = item.ItemNum,
                                                PlanDate = beginTime.Date,
                                                Period = dto.Period,
                                                OrdQty = item.QtyOrded - item.QtyWorked,
                                                WorkOrds = item.WorkOrd,
                                                Op = item.Op,
                                                IsActive = true,
                                                Status = "",
                                                CreateTime = DateTime.Now
                                            });
                                            //记录排产记录
                                            curScheduleRsts.Add(new ScheduleResultOpMaster
                                            {
                                                Domain = domain,
                                                WorkOrd = item.WorkOrd,
                                                Line = lineStart.Line,
                                                ItemNum = item.ItemNum,
                                                Op = item.Op,
                                                WorkDate = beginTime.Date,
                                                WorkQty = item.QtyOrded - item.QtyWorked,
                                                WorkStartTime = beginTime,
                                                WorkEndTime = endTime,
                                                CreateTime = DateTime.Now
                                            });
                                            //下一工单开始时间=当前工单结束时间，如果位于工作区间结尾，则为下一工作区间开始时间
                                            curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                            //结束时间位于工作区间结尾
                                            if (curPoint != null && endTime == curPoint.EndPoint)
                                            {
                                                //获取后续生产时间段
                                                curPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                //存在后续工作区间
                                                if (curPoint != null)
                                                {
                                                    endTime = curPoint.StartPoint;
                                                }
                                            }
                                            beginTime = endTime;
                                            //工单排产完成，排产时长=工单工作时长
                                            item.Worked = item.LbrVar;
                                            item.QtyWorked = item.QtyOrded;
                                        }

                                        //剩余可用生产时长
                                        residueTime = residueTime < 0 ? 0 : residueTime;
                                        //特殊工单处理完成，剩余生产时长大于0继续排正常工单
                                        if (residueTime > 0)
                                        {
                                            //处理正常工单开工时间
                                            workStartTime = endTime;
                                            //剩余产能继续排正常工单
                                            decimal sumAmount = Math.Floor(dto.Rate * residueTime / 60);
                                            //记录生产周期
                                            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 = workStartTime,
                                                WorkEndTime = dto.EndTime,
                                                CreateTime = DateTime.Now
                                            });
                                            //累计已排产数量
                                            sumQty += sumAmount;
                                        }
                                        //继续排下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                        //排产完毕，特殊工单时长置0
                                        sumTsTimes = 0;
                                        //当天的特殊工单排产完成
                                        isFullPC = true;
                                        //最后一个特殊工单清场时长置0
                                        lstCleanTime = 0m;
                                    }
                                    //当天的可用产能不满足特殊工单生产时长,则当天产能全部排特殊工单(至少最后一个特殊工单的生产时长不能满足)
                                    else
                                    {
                                        foreach (var item in workDtos)
                                        {
                                            if (item.LbrVar == item.Worked)//当前工单已排产
                                            {
                                                continue;
                                            }
                                            //当前工单剩余待排产时长(分钟)
                                            decimal needTime = item.LbrVar - item.Worked;
                                            //当天剩余产能满足当前工单的剩余待排产时长(则当前工单的清场时间必定排完)
                                            if (residueTime >= needTime)
                                            {
                                                //计算工单排产结束时间
                                                var curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                span = curPoint.EndPoint - beginTime;
                                                //当前工作时间段的有效生产时间(分钟)
                                                decimal effMins = (decimal)span.TotalMinutes;
                                                if (effMins >= needTime)//当前工作时间段即可满足产能
                                                {
                                                    endTime = beginTime.AddMinutes((double)needTime);
                                                }
                                                else
                                                {
                                                    //获取后续生产时间段
                                                    var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                    //剩余需要工作时长
                                                    decimal nextMins = needTime - effMins;
                                                    foreach (var p in nextPoints)
                                                    {
                                                        if (p.WorkMinutes >= nextMins)
                                                        {
                                                            endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                            break;
                                                        }
                                                        nextMins -= p.WorkMinutes;
                                                    }
                                                }

                                                //当天剩余可用生产时长
                                                residueTime -= needTime;
                                                //处理清场时间，两种场景：
                                                //1、residueTime<=item.WaitTime,结束时间加上剩余清场时长
                                                if (residueTime <= item.WaitTime)
                                                {
                                                    //仍需排产的清场时长
                                                    decimal otherTime = item.WaitTime - residueTime;
                                                    endTime = dto.EndTime.AddMinutes((double)otherTime);
                                                    residueTime = 0;
                                                }
                                                //2、residueTime>item.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                                else
                                                {
                                                    //清场时长
                                                    needTime = item.WaitTime;
                                                    //获取工单排产结束时间所处时间段
                                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                    span = curPoint.EndPoint - endTime;
                                                    //当前工作时间段的有效生产时间(分钟)
                                                    effMins = (decimal)span.TotalMinutes;
                                                    //当前工作时间段即可清场时长
                                                    if (effMins >= needTime)
                                                    {
                                                        endTime = endTime.AddMinutes((double)needTime);
                                                    }
                                                    else
                                                    {
                                                        //获取后续生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //剩余需要工作时长
                                                        decimal nextMins = needTime - effMins;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            if (p.WorkMinutes >= nextMins)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                break;
                                                            }
                                                            nextMins -= p.WorkMinutes;
                                                        }
                                                    }
                                                    residueTime -= needTime;
                                                }
                                                //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                                sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);

                                                //记录生产周期
                                                curSequences.Add(new PeriodSequenceDet
                                                {
                                                    Domain = domain,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    PlanDate = beginTime.Date,
                                                    Period = dto.Period,
                                                    OrdQty = item.QtyOrded - item.QtyWorked,
                                                    WorkOrds = item.WorkOrd,
                                                    Op = item.Op,
                                                    IsActive = true,
                                                    Status = "",
                                                    CreateTime = DateTime.Now
                                                });
                                                //记录排产记录
                                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                                {
                                                    Domain = domain,
                                                    WorkOrd = item.WorkOrd,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    Op = item.Op,
                                                    WorkDate = beginTime.Date,
                                                    WorkQty = item.QtyOrded - item.QtyWorked,
                                                    WorkStartTime = beginTime,
                                                    WorkEndTime = endTime,
                                                    CreateTime = DateTime.Now
                                                });
                                                //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                item.Worked = item.LbrVar;
                                                item.QtyWorked = item.QtyOrded;

                                                beginTime = endTime;
                                                if (residueTime > 0)
                                                {
                                                    //获取结束时间所处时间段
                                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                    if (endTime == curPoint.EndPoint)
                                                    {
                                                        var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                        endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                                    }
                                                    beginTime = endTime;
                                                }
                                                //当天可用产能已全部用完
                                                else
                                                {
                                                    break;
                                                }
                                            }
                                            //当天剩余产能不满足当前工单的剩余待排产时长
                                            else
                                            {
                                                //计算生产数量
                                                decimal qty = Math.Ceiling(residueTime / item.LbrVar * item.QtyOrded);
                                                //记录生产周期
                                                curSequences.Add(new PeriodSequenceDet
                                                {
                                                    Domain = domain,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    PlanDate = beginTime.Date,
                                                    Period = dto.Period,
                                                    OrdQty = qty,
                                                    WorkOrds = item.WorkOrd,
                                                    Op = item.Op,
                                                    IsActive = true,
                                                    Status = "",
                                                    CreateTime = DateTime.Now
                                                });
                                                //记录排产记录
                                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                                {
                                                    Domain = domain,
                                                    WorkOrd = item.WorkOrd,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    Op = item.Op,
                                                    WorkDate = beginTime.Date,
                                                    WorkQty = qty,
                                                    WorkStartTime = beginTime,
                                                    WorkEndTime = dto.EndTime,
                                                    CreateTime = DateTime.Now
                                                });
                                                item.Worked += residueTime;
                                                item.QtyWorked += qty;
                                                //特殊工单剩余待排产时长(分钟)
                                                sumTsTimes -= residueTime;
                                                residueTime = 0;
                                                break;
                                            }
                                        }
                                        //当天的特殊工单未排产完成
                                        isFullPC = false;
                                        //获取下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                    }
                                }
                                //不存在特殊工单(此时不想需要考虑清场时间)
                                else
                                {
                                    //记录生产周期
                                    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);
                                    isFstDay = false;
                                    isFullPC = true;
                                }
                            }
                            //剩余产能满足正常工单待排产数量，此时需要排清场时长
                            else
                            {
                                //当天可用生产时长
                                decimal residueTime = dto.EffTime;
                                //正常工单生产时长
                                decimal workTime = 0m;
                                DateTime workEndTime = workStartTime;
                                if (sumQty < lineStart.QtyRemain)
                                {
                                    #region 正常工单排产-开始
                                    //剩余需要排产的数量
                                    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);
                                    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;
                                    }
                                    #endregion 正常工单排产-结束
                                }

                                //当天剩余产能(分钟)
                                residueTime = residueTime < 0 ? 0 : residueTime;
                                if (sumTsTimes > 0)//存在特殊工单
                                {
                                    if (residueTime > 0)
                                    {
                                        #region 特殊工单排产-开始
                                        DateTime beginTime = workStartTime;//排产开始时间
                                        DateTime endTime = dto.EndTime;//排产结束时间
                                        workDtos = workDtos.OrderBy(p => p.Priority).ToList();
                                        //当天的可用产能满足特殊工单生产时长+清场时长(最后一个工单清场时间除外)
                                        if (residueTime >= sumTsTimes)
                                        {
                                            //最后一个工单
                                            var lastWork = workDtos.Last();
                                            //开始或结束时间所处时间段
                                            var curPoint = new LineWorkPointDto();
                                            foreach (var item in workDtos)
                                            {
                                                if (item.LbrVar == item.Worked)//当前工单已排产
                                                {
                                                    continue;
                                                }
                                                //当前工单排产需要时长
                                                decimal needTime = 0m;
                                                //最后一个特殊工单
                                                if (item.WorkOrd == lastWork.WorkOrd)
                                                {
                                                    //最后一个工单的生产时长+清场时长
                                                    needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                                    //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                                    if (residueTime >= needTime)
                                                    {
                                                        //计算工单排产结束时间
                                                        curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                        //获取排产结束时间所处以及之后的生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level >= curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //处理第一个时间段的开始时间
                                                        nextPoints[0].StartPoint = beginTime;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            span = p.EndPoint - p.StartPoint;
                                                            //当前工作时间段的有效生产时间
                                                            decimal effMins = (decimal)span.TotalMinutes;
                                                            if (effMins >= needTime)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)needTime);
                                                                break;
                                                            }
                                                            needTime -= effMins;
                                                            residueTime -= effMins;
                                                        }
                                                        //剩余可用时长
                                                        residueTime -= needTime;
                                                    }
                                                    //剩余可用工作时长不能满足清场时长
                                                    else
                                                    {
                                                        //还需排产的清场时间
                                                        decimal qcTime = needTime - residueTime;
                                                        endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                        residueTime = 0;
                                                    }
                                                    //最后一个工单的清场时长
                                                    lstCleanTime = 0m;
                                                }
                                                //最后一个特殊工单之前的工单：剩余排产时长和清场时间全部排产
                                                else
                                                {
                                                    //当前工单还需工作时长+工单的清场时长
                                                    needTime = item.LbrVar - item.Worked + item.WaitTime;
                                                    //计算工单排产结束时间
                                                    curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                    span = curPoint.EndPoint - beginTime;
                                                    //当天工作时间段的有效生产时间(分钟)
                                                    decimal effMins = (decimal)span.TotalMinutes;
                                                    if (effMins >= needTime)//当前工作时间段即可满足产能
                                                    {
                                                        endTime = beginTime.AddMinutes((double)needTime);
                                                    }
                                                    else
                                                    {
                                                        //获取后续生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //剩余需要工作时长
                                                        decimal nextMins = needTime - effMins;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            if (p.WorkMinutes >= nextMins)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                break;
                                                            }
                                                            nextMins -= p.WorkMinutes;
                                                        }
                                                    }
                                                    residueTime -= needTime;
                                                }
                                                
                                                //记录生产周期
                                                curSequences.Add(new PeriodSequenceDet
                                                {
                                                    Domain = domain,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    PlanDate = beginTime.Date,
                                                    Period = dto.Period,
                                                    OrdQty = item.QtyOrded - item.QtyWorked,
                                                    WorkOrds = item.WorkOrd,
                                                    Op = item.Op,
                                                    IsActive = true,
                                                    Status = "",
                                                    CreateTime = DateTime.Now
                                                });
                                                //记录排产记录
                                                curScheduleRsts.Add(new ScheduleResultOpMaster
                                                {
                                                    Domain = domain,
                                                    WorkOrd = item.WorkOrd,
                                                    Line = lineStart.Line,
                                                    ItemNum = item.ItemNum,
                                                    Op = item.Op,
                                                    WorkDate = beginTime.Date,
                                                    WorkQty = item.QtyOrded - item.QtyWorked,
                                                    WorkStartTime = beginTime,
                                                    WorkEndTime = endTime,
                                                    CreateTime = DateTime.Now
                                                });
                                                //下一工单开始时间=当前工单结束时间，如果位于工作区间结尾，则为下一工作区间开始时间
                                                curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                //结束时间位于工作区间结尾
                                                if (curPoint != null && endTime == curPoint.EndPoint)
                                                {
                                                    //获取后续生产时间段
                                                    var nextPoint = workPoints.Where(p => p.Level == curPoint.Level + 1).FirstOrDefault();
                                                    if (nextPoint != null)//存在后续工作区间
                                                    {
                                                        endTime = nextPoint.StartPoint;
                                                    }
                                                }
                                                beginTime = endTime;
                                                //工单排产完成，排产时长=工单工作时长
                                                item.Worked = item.LbrVar;
                                                item.QtyWorked = item.QtyOrded;
                                            }
                                            //排产完毕，特殊工单时长置0
                                            sumTsTimes = 0;
                                            //当天的特殊工单以排产完成
                                            isFullPC = true;
                                            //最后一个工单的清场时间置0
                                            lstCleanTime = 0m;
                                        }
                                        //当天的可用产能不满足特殊工单生产时长,则当天产能全部排特殊工单(至少最后一个特殊工单的生产时长不能满足)
                                        else
                                        {
                                            foreach (var item in workDtos)
                                            {
                                                if (item.LbrVar == item.Worked)//当前工单已排产
                                                {
                                                    continue;
                                                }
                                                //当前工单剩余待排产时长(分钟)
                                                decimal needTime = item.LbrVar - item.Worked;
                                                //当天剩余产能满足当前工单的剩余待排产时长(则当前工单的清场时间必定排完)
                                                if (residueTime >= needTime)
                                                {
                                                    //计算工单排产结束时间
                                                    var curPoint = workPoints.Find(p => p.StartPoint <= beginTime && beginTime <= p.EndPoint);
                                                    span = curPoint.EndPoint - beginTime;
                                                    //当前工作时间段的有效生产时间(分钟)
                                                    decimal effMins = (decimal)span.TotalMinutes;
                                                    if (effMins >= needTime)//当前工作时间段即可满足产能
                                                    {
                                                        endTime = beginTime.AddMinutes((double)needTime);
                                                    }
                                                    else
                                                    {
                                                        //获取后续生产时间段
                                                        var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                        //剩余需要工作时长
                                                        decimal nextMins = needTime - effMins;
                                                        foreach (var p in nextPoints)
                                                        {
                                                            if (p.WorkMinutes >= nextMins)
                                                            {
                                                                endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                break;
                                                            }
                                                            nextMins -= p.WorkMinutes;
                                                        }
                                                    }

                                                    //当天剩余可用生产时长
                                                    residueTime -= needTime;
                                                    //处理清场时间，两种场景：
                                                    //1、residueTime<=item.WaitTime,结束时间加上剩余清场时长
                                                    if (residueTime <= item.WaitTime)
                                                    {
                                                        //仍需排产的清场时长
                                                        decimal otherTime = item.WaitTime - residueTime;
                                                        endTime = dto.EndTime.AddMinutes((double)otherTime);
                                                        residueTime = 0;
                                                    }
                                                    //2、residueTime>item.WaitTime,剩余时长大于清场时长，需要过滤休息时间
                                                    else
                                                    {
                                                        //清场时长
                                                        needTime = item.WaitTime;
                                                        //获取工单排产结束时间所处时间段
                                                        curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                        span = curPoint.EndPoint - endTime;
                                                        //当前工作时间段的有效生产时间(分钟)
                                                        effMins = (decimal)span.TotalMinutes;
                                                        //当前工作时间段即可清场时长
                                                        if (effMins >= needTime)
                                                        {
                                                            endTime = endTime.AddMinutes((double)needTime);
                                                        }
                                                        else
                                                        {
                                                            //获取后续生产时间段
                                                            var nextPoints = workPoints.Where(p => p.Level > curPoint.Level).OrderBy(p => p.Level).ToList();
                                                            //剩余需要工作时长
                                                            decimal nextMins = needTime - effMins;
                                                            foreach (var p in nextPoints)
                                                            {
                                                                if (p.WorkMinutes >= nextMins)
                                                                {
                                                                    endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                                    break;
                                                                }
                                                                nextMins -= p.WorkMinutes;
                                                            }
                                                        }
                                                        residueTime -= needTime;
                                                    }
                                                    //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                                    sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);

                                                    //记录生产周期
                                                    curSequences.Add(new PeriodSequenceDet
                                                    {
                                                        Domain = domain,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        PlanDate = beginTime.Date,
                                                        Period = dto.Period,
                                                        OrdQty = item.QtyOrded - item.QtyWorked,
                                                        WorkOrds = item.WorkOrd,
                                                        Op = item.Op,
                                                        IsActive = true,
                                                        Status = "",
                                                        CreateTime = DateTime.Now
                                                    });
                                                    //记录排产记录
                                                    curScheduleRsts.Add(new ScheduleResultOpMaster
                                                    {
                                                        Domain = domain,
                                                        WorkOrd = item.WorkOrd,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        Op = item.Op,
                                                        WorkDate = beginTime.Date,
                                                        WorkQty = item.QtyOrded - item.QtyWorked,
                                                        WorkStartTime = beginTime,
                                                        WorkEndTime = endTime,
                                                        CreateTime = DateTime.Now
                                                    });
                                                    //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                    item.Worked = item.LbrVar;
                                                    item.QtyWorked = item.QtyOrded;

                                                    beginTime = endTime;
                                                    if (residueTime > 0)
                                                    {
                                                        curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                        if (endTime == curPoint.EndPoint)
                                                        {
                                                            var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                            endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                                            beginTime = endTime;
                                                        }
                                                        
                                                    }
                                                    //当天可用产能已全部用完
                                                    else
                                                    {
                                                        break;
                                                    }
                                                }
                                                else//当天剩余产能不满足当前工单的剩余待排产时长
                                                {
                                                    //计算生产数量
                                                    decimal qty = Math.Ceiling(residueTime / item.LbrVar * item.QtyOrded);
                                                    //记录生产周期
                                                    curSequences.Add(new PeriodSequenceDet
                                                    {
                                                        Domain = domain,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        PlanDate = beginTime.Date,
                                                        Period = dto.Period,
                                                        OrdQty = qty,
                                                        WorkOrds = item.WorkOrd,
                                                        Op = item.Op,
                                                        IsActive = true,
                                                        Status = "",
                                                        CreateTime = DateTime.Now
                                                    });
                                                    //记录排产记录
                                                    curScheduleRsts.Add(new ScheduleResultOpMaster
                                                    {
                                                        Domain = domain,
                                                        WorkOrd = item.WorkOrd,
                                                        Line = lineStart.Line,
                                                        ItemNum = item.ItemNum,
                                                        Op = item.Op,
                                                        WorkDate = beginTime.Date,
                                                        WorkQty = qty,
                                                        WorkStartTime = beginTime,
                                                        WorkEndTime = dto.EndTime,
                                                        CreateTime = DateTime.Now
                                                    });
                                                    item.Worked += residueTime;
                                                    item.QtyWorked += qty;
                                                    //特殊工单剩余待排产时长(分钟)
                                                    sumTsTimes -= residueTime;
                                                    residueTime = 0;
                                                    break;
                                                }
                                            }
                                            //当天的特殊工单未排产完成
                                            isFullPC = false;
                                            //获取下一个工作日
                                            workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                            isFstDay = false;
                                        }
                                        #endregion 特殊工单排产-结束
                                    }
                                    else
                                    {
                                        //继续排下一个工作日
                                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                        isFstDay = false;
                                        //当天的特殊工单未排产完成
                                        isFullPC = false;
                                    }
                                }
                            }
                        }
                    }
                }
                //记录已排产特殊工单
                ypcWorkOrds.AddRange(workDtos.Select(p=>p.WorkOrd).ToList());
            }
            //记录排产结果
            periodsDet.AddRange(curSequences);
            scheduleResults.AddRange(curScheduleRsts);
        }

        /// <summary>
        /// 特殊工单排产:和正常工单不共用产线的特殊工单
        /// </summary>
        /// <param name="workOrds">特殊工单</param>
        /// <param name="periodsDet">生产周期</param>
        /// <param name="scheduleResults">排产结果</param>
        public void TsLineSchedule(List<WorkOrdMstDto> workOrds, List<PeriodSequenceDet> periodsDet, List<ScheduleResultOpMaster> scheduleResults)
        {
            foreach (var item in workOrds)
            {
                //工单生产时长(分钟)
                decimal sumTimes = item.LbrVar;
                //工单的排产开始时间
                DateTime workStartTime = item.OrdDate;
                //当前产线的工作日历
                var mLCalendars = calendars.Where(p => p.ProdLine == item.ProdLine || string.IsNullOrEmpty(p.ProdLine)).ToList();
                //当前产线的休息时间设置
                var mlqtyWorkDtls = qualityLines.Where(p => p.ProdLine == item.ProdLine).ToList();
                LineStartDto lineStart = new LineStartDto();
                lineStart.RecID = 0;
                lineStart.Line = item.ProdLine;
                lineStart.Op = item.Op;
                lineStart.StartTime = workStartTime;
                lineStart.Rate = 0;
                while (sumTimes > 0)
                {
                    //获取当天的工作时间段
                    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);
                    //获取当天的产能
                    LineScheduledDto dto = GetScheduledPoint(lineStart, workStartTime, mLCalendars, mlqtyWorkDtls);
                    //当天的可用生产时长不能满足特殊工单生产时长
                    if (dto.EffTime < sumTimes)
                    {
                        decimal qty = Math.Ceiling(dto.EffTime / item.LbrVar * item.QtyOrded);
                        //记录生产周期
                        periodsDet.Add(new PeriodSequenceDet
                        {
                            Domain = domain,
                            Line = item.ProdLine,
                            ItemNum = item.ItemNum,
                            PlanDate = workStartTime.Date,
                            Period = dto.Period,
                            OrdQty = qty,
                            WorkOrds = item.WorkOrd,
                            Op = item.Op,
                            IsActive = true,
                            Status = "",
                            CreateTime = DateTime.Now
                        });
                        //记录排产记录
                        scheduleResults.Add(new ScheduleResultOpMaster
                        {
                            Domain = domain,
                            WorkOrd = item.WorkOrd,
                            Line = item.ProdLine,
                            ItemNum = item.ItemNum,
                            Op = item.Op,
                            WorkDate = workStartTime.Date,
                            WorkQty = qty,
                            WorkStartTime = dto.StartTime,
                            WorkEndTime = dto.EndTime,
                            CreateTime = DateTime.Now
                        });
                        //剩余待排产时长
                        sumTimes -= dto.EffTime;
                        //已排产数量
                        item.QtyWorked += qty;
                        item.Worked += dto.EffTime;
                        //继续排下一个工作日
                        workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                    }
                    //最后一天的产能全部占用或只能占用一部分
                    else
                    {
                        //结束时间
                        DateTime workEndTime = workStartTime;
                        //需要排产时长=剩余生产时长(分钟) + 清场时长 
                        decimal workTime = sumTimes + item.WaitTime;
                        //当天可用时长满足生产时长+清场时长
                        if (dto.EffTime > workTime)
                        {
                            //排产开始时间位于哪个时间段
                            var curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                            TimeSpan 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;
                                }
                            }
                        }
                        //当天可用时长满足生产时长，但是不满足清场时长
                        else {
                            //剩余清场时长
                            decimal needTime = workTime - dto.EffTime;
                            workEndTime = dto.EndTime.AddMinutes((double)needTime);
                        }

                        //记录生产周期
                        periodsDet.Add(new PeriodSequenceDet
                        {
                            Domain = domain,
                            Line = item.ProdLine,
                            ItemNum = item.ItemNum,
                            PlanDate = workStartTime.Date,
                            Period = dto.Period,
                            OrdQty = item.QtyOrded - item.QtyWorked,
                            WorkOrds = item.WorkOrd,
                            Op = item.Op,
                            IsActive = true,
                            Status = "",
                            CreateTime = DateTime.Now
                        });
                        //记录排产记录
                        scheduleResults.Add(new ScheduleResultOpMaster
                        {
                            Domain = domain,
                            WorkOrd = item.WorkOrd,
                            Line = item.ProdLine,
                            ItemNum = item.ItemNum,
                            Op = item.Op,
                            WorkDate = workStartTime.Date,
                            WorkQty = item.QtyOrded - item.QtyWorked,
                            WorkStartTime = workStartTime,
                            WorkEndTime = workEndTime,
                            CreateTime = DateTime.Now
                        });
                        sumTimes = 0;
                        item.QtyWorked = item.QtyOrded;
                        item.Worked = item.LbrVar;
                    }
                }
            }
        }

        /// <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).First();
            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;
            //计算当天的产能(向下取整)
            scheduledDto.ProductQty = Math.Floor(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)
        {
            int op = routing.OP;
            DateTime actStart = DateTime.Now.Date.AddDays(1);
            LineStartDto lineStart = new LineStartDto();
            //获取工序对应的产线,根据优先级排序
            var lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == op).OrderBy(p => p.Sequence).ToList();
            //获取第一条产线排产结束时间
            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 (workOrd.Status.ToLower() == "w" && workOrd.JointTyped.ToUpper() !="B")
            {
                lineStart.setupTime = 0m;
            }
            lineStart.Op = op;
            lineStart.WaitTime = routing.WaitTime * 60;
            lineStart.QtyRemain = workOrd.QtyOrded - routing.QtyComplete;
            return lineStart;
        }

        /// <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)
        {
            int op = routing.OP;
            LineStartDto startDto = new LineStartDto();
            //获取产线
            var lines = prodLines.Where(p => p.Part == workOrd.ItemNum && p.Op == op).OrderBy(p=>p.Sequence).ToList();
            //获取第一条产线排产结束时间
            var schedule = allResults.Where(p => p.Line == lines[0].Line).OrderByDescending(p => p.WorkEndTime).FirstOrDefault();
            DateTime startTime = CalcStartTimeWithSetUpTime(lines[0], lineStart.StartTime, 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], lineStart.StartTime, 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 (workOrd.Status.ToLower() == "w" && workOrd.JointTyped.ToUpper() != "B")
            {
                startDto.setupTime = 0m;
            }
            startDto.Op = op;
            startDto.WaitTime = routing.WaitTime * 60;
            startDto.QtyRemain = workOrd.QtyOrded - routing.QtyComplete;
            return startDto;
        }

        /// <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();
            //当前时间段可用时长
            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);
                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)
            {
                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();
        }
    }
}