MES / MES-BaseMes10.0 · Files

using Hh.Mes.Common.log;
using Hh.Mes.POJO.ApiEntity;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.POJO.Response;
using Hh.Mes.POJO.ViewModel;
using Hh.Mes.Service.Repository;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Security.Principal;
using static Microsoft.AspNetCore.Hosting.Internal.HostingApplication;

namespace Hh.Mes.Service.Material
{
    /// <summary>
    /// 套料计算
    /// </summary>
    public class CutPlanCalculateService : RepositorySqlSugar<dynamic>
    {
        #region 属性

        /// <summary>
        /// 同步锁，套料要避免同步并发
        /// </summary>
        public static object LockNesting { get; set; } = new object();

        //套料结果
        public TotalData totalData { get; set; } = new TotalData();

        //可套料库存
        public List<base_inventory> inventoryList = new List<base_inventory>();

        //已经使用库存
        public List<int> USEinventoryList = new List<int>();

        //可以套料管段
        public List<bus_workOrder_detail> workOrderDetailQueryable = new List<bus_workOrder_detail>();

        /// <summary>
        /// 获取字典的废料长度
        /// </summary>
        public decimal CutPlanLength
        {
            get
            {
                var CutPlan = GetDictionaryDictValue("CuttingWasteLength", "CutConfig");
                if (CutPlan == null)
                    CutPlan = "250";

                return decimal.Parse(CutPlan);
            }
        }

        /// <summary>
        /// 获取字典首段坡口损耗
        /// </summary>
        public decimal BevelLossLength
        {
            get
            {
                var BevelLoss = GetDictionaryDictValue("BevelLoss", "CutConfig");
                if (BevelLoss == null)
                    BevelLoss = "0";

                return decimal.Parse(BevelLoss);
            }
        }

        /// <summary>
        /// 获取字典的管材长度
        /// </summary>
        //public decimal PipeLength
        //{
        //    get
        //    {
        //        var PipeLength = GetDictionaryDictValue("PipeLengthConfig", "CutConfig");
        //        if (PipeLength == null)
        //            PipeLength = "5950";

        //        return decimal.Parse(PipeLength);
        //    }
        //}

        /// <summary>
        /// 获取字典的切割损耗
        /// </summary>
        public decimal CutFlanLength
        {
            get
            {
                var cutFlan = "0"; //GetDictionaryDictValue("CutFlanConfig", "CutConfig");
                if (cutFlan == null)
                    cutFlan = "0";

                return decimal.Parse(cutFlan);
            }
        }

        /// <summary>
        /// 登陆用户
        /// </summary>
        private string SysUser
        {
            get
            {
                return sysWebUser?.Account;
            }
        }
        #endregion

        #region 套料相关


        /// <summary>
        /// 套料计算是查询可套料物料
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        private void GetinventoryList(List<bus_workOrder_detail> wDList)
        {

            #region  查询可以套料库存

            var materialCodeList = wDList.Select(x => x.cutMaterCode).Distinct().ToList();

            //可套料库存
            var inventory = Context.Queryable<base_inventory>().Where(x =>
                                            x.pipeLength > CutPlanLength
                                            && x.useState == (int)InventoryUseState.未套料
                                            && materialCodeList.Contains(x.materialCode)
                                            ).OrderBy(x => x.pipeLength).ToList();

            inventoryList = inventory;
            #endregion

        }

        /// <summary>
        /// 套料计算
        /// </summary>
        /// <param name="cutHeadIds">套料指定的工单头表ID</param>
        /// <returns></returns>
        public dynamic Calculation(string cutHeadIds)
        {
            var response = new Response();
            try
            {
                lock (LockNesting)
                {
                    #region  套料计算

                    if (string.IsNullOrWhiteSpace(cutHeadIds))
                    {
                        return response.ResponseError($"请选择工单！");
                    }

                    List<int> cutHeadList = cutHeadIds.Split(',').Select(t => int.Parse(t)).ToList();

                    //工单
                    var workOrderHeadQueryable = Context.Queryable<bus_workOrder_head>()
                                                       .Where(x => cutHeadList.Contains(x.id) && !x.isScrap).ToList();

                    if (workOrderHeadQueryable.Count == 0)
                    {
                        return response.ResponseError($"没有状态为【套料】工序的工单，不能套料！");
                    }

                    var headKeysList = workOrderHeadQueryable.Select(x => x.keys).Distinct().ToList();

                    //工单明细
                    workOrderDetailQueryable = Context.Queryable<bus_workOrder_detail>()
                                                       .Where(x => headKeysList.Contains(x.headKeys) && x.state == (int)EnumOrderBodyStatus.初始化 && x.workCenterCode == EnumoprSequenceCode.套料).ToList();
                    if (workOrderDetailQueryable.Count == 0)
                    {
                        return response.ResponseError($"没有状态为【初始】的工单明细，不能套料！");
                    }

                    //查询可以套料库存物料
                    GetinventoryList(workOrderDetailQueryable);

                    if (inventoryList.Count == 0)
                    {
                        return response.ResponseError($"没有可套料库存物料！");
                    }

                    //查询明细的下一个工单
                    foreach (var item in workOrderDetailQueryable)
                    {
                        var nowDetail = Context.Queryable<bus_workOrder_detail>()
                              .Where(x => x.headKeys == item.headKeys && x.workCenterCode != EnumoprSequenceCode.套料)
                              .OrderBy(x => x.serialNumber, OrderByType.Asc).First();

                        item.nowWorkCenterCode = nowDetail.workCenterCode;
                        item.nowWorkCenterName = nowDetail.oprSequenceName;

                    }

                    //物料分组
                    var cutMaterCodeList = workOrderDetailQueryable.Select(t => t.cutMaterCode).ToList().Distinct().ToList();

                    //单管的管段明细，按照物料类型分组暂存到List
                    var spoolList = new List<List<bus_workOrder_detail>>();


                    #region 数据筛选  通过切割工单明细物料，从大到小排序，然后套料 
                    foreach (var materCode in cutMaterCodeList)
                    {
                        var cutDetailTemp = workOrderDetailQueryable.Where(x => x.cutMaterCode == materCode).OrderByDescending(x => x.cuttingLength).ToList();
                        spoolList.Add(cutDetailTemp);
                    }

                    foreach (var partList in spoolList)
                    {


                        //整根套料
                        foreach (var inventory1 in inventoryList)
                        {
                            //已经使用的库存管材跳过
                            var use = USEinventoryList.Where(x => x == inventory1.id).ToList();
                            if (use.Count > 0)
                            {
                                continue;
                            }

                            //1.切割长度+首段坡口损耗=管材长度
                            //2.管材长度-首段坡口损耗-废料长度=切割长度
                            //3.管材长度>废料长度
                            var part1 = partList.Where(x =>
                                            ((x.cuttingLength + BevelLossLength) == inventory1.pipeLength
                                            || inventory1.pipeLength - BevelLossLength - CutPlanLength == x.cuttingLength)
                                            && inventory1.pipeLength > CutPlanLength
                                            && x.cutMaterCode == inventory1.materialCode
                                            && workOrderDetailQueryable.Contains(x)
                                            ).ToList();

                            //添加套料方案，每次只套料一个库存
                            if (part1.Count > 0)
                            {
                                List<bus_workOrder_detail> list1 = new List<bus_workOrder_detail>();
                                list1.Add(part1[0]);
                                USEinventoryList.Add(inventory1.id);
                                AddScheme(workOrderHeadQueryable, list1, inventory1);
                                // 移除已经套料管段
                                workOrderDetailQueryable.RemoveAll(x => part1[0].id == x.id);
                            }
                        }

                        //多段套料
                        foreach (var inventory1 in inventoryList)
                        {
                            //已经使用的库存管材跳过
                            var use = USEinventoryList.Where(x => x == inventory1.id).ToList();
                            if (use.Count > 0)
                            {
                                continue;
                            }

                            //单根管段匹配的最小长度
                            var pipeLength = inventory1.pipeLength - CutPlanLength - BevelLossLength;

                            //1.找出管段长度小于"单根管段匹配的最小长度"， 进行多管段套料
                            //2.进行工作中心分组
                            var partList2 = partList.Where(x =>
                                                        x.cuttingLength < pipeLength
                                                        && x.cutMaterCode == inventory1.materialCode
                                                        && workOrderDetailQueryable.Contains(x)
                                                        ).ToList();

                            var partList2G = partList2.Select(x => x.nowWorkCenterCode).Distinct().ToList();
                            var partListG = partList2.Where(x => x.nowWorkCenterCode == partList2G[0]).ToList();
                            //套料计算，每次只套料一个库存
                            if (partListG.Count > 0)
                            {
                                USEinventoryList.Add(inventory1.id);
                                PartCalculation(workOrderHeadQueryable, partListG, inventory1);
                            }

                        }
                    }

                    //记录未套料工单明细
                    workOrderDetailQueryable.ForEach(x => totalData.notWorkOrderDetailList.Add(x));
                    //记录未套料工单
                    var headKeyList = workOrderDetailQueryable.Select(x => x.headKeys).ToList().Distinct().ToList();
                    var notworkOrderHeadList = workOrderHeadQueryable.Where(x => headKeyList.Contains(x.keys)).ToList();
                    notworkOrderHeadList.ForEach(x => totalData.notWorkOrderheadList.Add(x));

                    //移除不能套料工单（已经把可以套料的管段都进行了套料，剩下的就是不能套料的管段，把不能套料的明细关联的工单头移除，剩下的工单都是已经套料完的）
                    workOrderHeadQueryable.RemoveAll(x => notworkOrderHeadList.Exists(y => y.keys == x.keys));

                    //记录未使用的库存物料
                    inventoryList = inventoryList.Where(x => !USEinventoryList.Contains(x.id)).ToList();
                    totalData.notInventoryList = inventoryList;

                    //记录工单头
                    totalData.workOrderheadList = workOrderHeadQueryable;
                    #endregion

                    response.Message = "计算成功！";
                    return response;

                    #endregion
                }
            }
            catch (Exception ex)
            {
                return response.ResponseError($"套料计算发生异常，原因：{ex.Message}");
            }
        }

        /// <summary>
        /// 对管段进行套料计算，按照最大利用来套料，可能出现一个工单的管段分散在多个管材上
        /// </summary>
        private void PartCalculation(List<bus_workOrder_head> workOrderHeadList, List<bus_workOrder_detail> partListG, base_inventory inventory)
        {
            #region 单根管材套料

            //管段组
            var detailGroup = new List<bus_workOrder_detail>();
            //损耗
            decimal loss = 0;
            //配置的管材长度
            var pipeLength = inventory.pipeLength - BevelLossLength;
            //配置的废料长度
            var cutPlanLength = CutPlanLength;
            //配置的切割余量
            var cutFlanLength = CutFlanLength;

            var Detail = new List<bus_workOrder_detail>();
            foreach (var part in partListG)
            {
                //"管段+损耗"等于管材长度，就可用
                if (pipeLength == part.cuttingLength + loss)
                {
                    detailGroup.Add(part);
                    loss = loss + part.cuttingLength + cutFlanLength;
                    Detail.Add(part);
                    break;
                }

                //"管段+废料长度+切割余量+损耗"小于管材长度，就可用
                if (pipeLength >= part.cuttingLength + cutPlanLength + cutFlanLength + loss)
                {
                    detailGroup.Add(part);
                    loss = loss + part.cuttingLength + cutFlanLength;
                    Detail.Add(part);
                }
            }

            // 移除已经套料管段
            workOrderDetailQueryable.RemoveAll(x => Detail.Exists(y => y.id == x.id));

            if (detailGroup.Count > 0)
            {
                AddScheme(workOrderHeadList, detailGroup, inventory);
            }


            #endregion
        }

        /// <summary>
        /// 添加套料方案
        /// </summary>
        /// <param name="workOrderHeadList">工单头表</param>
        /// <param name="workOrderDetailList">工单明细表</param>
        /// <param name="inventory">库存物料</param>
        private void AddScheme(List<bus_workOrder_head> workOrderHeadList, List<bus_workOrder_detail> detailGroup, base_inventory inventory)
        {
            #region 添加套料方案
            detailGroup = detailGroup.OrderBy(x => x.cuttingLength).ToList();
            TotalModel totalModel = new TotalModel();

            var loss = detailGroup.Select(x => x.cuttingLength);

            // 总切割长度 = 总损耗长度 + 总管段长度+首段坡口损耗
            var sumProducts = detailGroup.Sum(x => x.cuttingLength);
            sumProducts = sumProducts + CutFlanLength + BevelLossLength;

            //利用率 = 总切割长度 / 管材长度
            var percentage = sumProducts / inventory.pipeLength;

            //表头Key
            var keys = Guid.NewGuid();

            //余料码
            var oddmentsCode = "";
            if (inventory.pipeLength - sumProducts > 0)
            {
                oddmentsCode = GetOddmentsCode(inventory.pipeLength - sumProducts, detailGroup[0].id);
            }

            //套料方案头
            var cutplanHead = new bus_cutplan_head();
            cutplanHead.keys = keys;
            cutplanHead.materialCode = inventory.materialCode;
            cutplanHead.pipeLength = inventory.pipeLength;
            cutplanHead.lotNo = inventory.pipeSN;
            cutplanHead.lossCount = percentage;
            cutplanHead.oddmentsCode = oddmentsCode;
            cutplanHead.oddmentsLength = inventory.pipeLength - sumProducts;
            //cutplanHead.lineCode = "线体";
            cutplanHead.planStartTime = DateTime.Now.ToString("yyyy-MM-dd");
            cutplanHead.level = 1;
            cutplanHead.state = (int)EnumCutPlanHeadStatus.初始;
            cutplanHead.createTime = DateTime.Now.ToString();
            cutplanHead.createBy = SysUser;
            cutplanHead.workCenterCode = detailGroup[0].nowWorkCenterCode;
            cutplanHead.nowWorkCenterCode = detailGroup[0].nowWorkCenterCode;
            cutplanHead.nowWorkCenterName = detailGroup[0].nowWorkCenterName;

            //套料明细
            List<bus_cutplan_detail> detaillis = new List<bus_cutplan_detail>();

            //切割优先级
            var Level = detailGroup.Count;

            foreach (var item in detailGroup)
            {
                //明细对应头表
                var cutplan = workOrderHeadList.Where(x => x.keys == item.headKeys).First();
                //追踪码
                //var barCode = GetBarCode(item.id);

                var bodyKeys = Guid.NewGuid();

                var cutplanDetail = new bus_cutplan_detail();
                cutplanDetail.id = item.id;
                cutplanDetail.bodyKeys = bodyKeys;
                cutplanDetail.headKeys = keys;
                cutplanDetail.workOrderHeadKeys = cutplan.keys;
                cutplanDetail.workOrderDetailKeys = item.bodyKeys;
                cutplanDetail.iwpNo = cutplan.workOrderCode;
                cutplanDetail.barCode = item.barCode;
                cutplanDetail.cuttingLength = item.cuttingLength;
                cutplanDetail.cutFlanConfig = CutFlanLength;
                cutplanDetail.cutState = (int)EnumCutPlanDetailStatus.初始;
                cutplanDetail.cutLevel = Level;
                cutplanDetail.isendproduct = item.isEndProduct;
                cutplanDetail.createTime = DateTime.Now;
                cutplanDetail.createBy = SysUser;
                //页面展示使用
                cutplanDetail.parentTypeId = keys;
                cutplanDetail.keys = bodyKeys;

                detaillis.Add(cutplanDetail);

                //工单明细记录追踪码，套料保存时使用
                //item.barCode = barCode;
                item.state = (int)EnumOrderBodyStatus.已完成;
                item.actualEndTime = DateTime.Now;
                item.updateBy = SysUser;
                item.updateTime = DateTime.Now;
                totalData.workOrderDetailList.Add(item);

                Level--;
            }

            //记录套料
            totalModel.cutplanHead = cutplanHead;
            totalModel.planDetailList = detaillis;
            totalModel.Percentage = percentage.ToString("0.00%");

            totalData.totalModel.Add(totalModel);

            #endregion
        }

        /// <summary>
        /// 生成余料编码
        /// </summary>
        /// <returns></returns>
        private string GetOddmentsCode(decimal Length, int ID)
        {
            //码前缀
            string prefix = "Y";
            //废料长度
            var cutPlanLength = CutPlanLength;

            if (cutPlanLength > Length)
            {
                prefix = "F";
            }

            string Code = DateTime.Now.ToString("yyMMdd");

            return prefix + Code + ID.ToString();
        }

        /// <summary>
        /// 生成追踪码
        /// </summary>
        /// <returns></returns>
        //private string GetBarCode(int ID)
        //{
        //    return (100000 + ID).ToString();
        //}

        /// <summary>
        /// 查询可套料工单
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public dynamic GetCutterInfo(string time)
        {
            var response = new Response();
            try
            {
                #region  查询 工单头、明细 可以套料库存

                CutterInfo list = new CutterInfo();

                if (string.IsNullOrWhiteSpace(time))
                {
                    return response.ResponseError($"请选择日期！");
                }


                var workOrderheadKeysList = Context.Queryable<bus_workOrder_detail>()
                                                   .Where(x => SqlSugar.SqlFunc.DateIsSame(x.planStartTime, DateTime.Parse(time))
                                                   && x.oprSequenceCode == EnumoprSequenceCode.套料 && x.state == (int)EnumOrderBodyStatus.初始化)
                                                   .GroupBy(x => x.headKeys).Select(x => x.headKeys).ToList();

                //工单
                var workOrderHeadQueryable = Context.Queryable<bus_workOrder_head>()
                                                   .Where(x => workOrderheadKeysList.Contains(x.keys)).ToList();

                if (workOrderHeadQueryable.Count == 0)
                {
                    return response.ResponseError($"未查询到可以【套料】的工单。条件:计划时间是【{time}】当前工序【{EnumoprSequenceCode.套料}】！");
                }

                //工单明细
                foreach (var item in workOrderHeadQueryable)
                {
                    var detailList = Context.Queryable<bus_workOrder_detail>()
                                                   .Where(x => x.headKeys == item.keys && x.state == (int)EnumOrderBodyStatus.初始化 && x.workCenterCode == EnumoprSequenceCode.套料).ToList();

                    var nowDetail = Context.Queryable<bus_workOrder_detail>()
                                                   .Where(x => x.headKeys == item.keys && x.workCenterCode != EnumoprSequenceCode.套料)
                                                   .OrderBy(x => x.serialNumber, OrderByType.Asc).First();

                    detailList.ForEach(x => { x.parentTypeId = x.headKeys; x.keys = x.bodyKeys; });

                    //添加一个父对象，页面展示需要
                    bus_workOrder_detail workOrderDetail = new bus_workOrder_detail();
                    workOrderDetail.id = item.id;
                    workOrderDetail.keys = item.keys;
                    workOrderDetail.workOrderCode = item.workOrderCode;
                    workOrderDetail.nowWorkCenterCode = nowDetail.workCenterCode;
                    workOrderDetail.nowWorkCenterName = nowDetail.oprSequenceName;
                    workOrderDetail.parentTypeId = Guid.Parse("00000000-0000-0000-0000-000000000000");

                    list.cutList.Add(workOrderDetail);

                    detailList.ForEach(x => list.cutList.Add(x));
                }

                response.Code = 200;
                response.Result = list.cutList;
                return response;

                #endregion
            }
            catch (Exception ex)
            {
                return response.ResponseError($"查询发生异常，原因：{ex.Message}");
            }
        }

        /// <summary>
        /// 查询可套料物料
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public dynamic GetMaterialInfo(string time)
        {
            var response = new Response();
            try
            {
                #region  查询 工单头、明细 可以套料库存

                CutterInfo list = new CutterInfo();

                if (string.IsNullOrWhiteSpace(time))
                {
                    return response.ResponseError($"请选择日期！");
                }


                var materialCodeList = Context.Queryable<bus_workOrder_detail>()
                                                   .Where(x => SqlSugar.SqlFunc.DateIsSame(x.planStartTime, DateTime.Parse(time))
                                                   && x.oprSequenceCode == EnumoprSequenceCode.套料 && x.state == (int)EnumOrderBodyStatus.初始化)
                                                   .GroupBy(x => x.cutMaterCode).Select(x => x.cutMaterCode).ToList();

                //可套料库存
                var inventoryList = Context.Queryable<base_inventory>().Where(x =>
                                                x.pipeLength > CutPlanLength
                                                && x.useState == (int)InventoryUseState.未套料
                                                && materialCodeList.Contains(x.materialCode)
                                                ).OrderBy(x => x.pipeLength).ToList();

                list.inventoryList = inventoryList;

                response.Code = 200;
                response.Result = list.inventoryList;
                return response;

                #endregion
            }
            catch (Exception ex)
            {
                return response.ResponseError($"查询发生异常，原因：{ex.Message}");
            }
        }

        /// <summary>
        /// 页面套料计算
        /// </summary>
        /// <param name="cutHeadIds">套料指定的工单头表ID</param>
        /// <returns></returns>
        public dynamic GteCalculation(string cutHeadIds)
        {
            var response = new Response();
            try
            {
                lock (LockNesting)
                {
                    #region 页面套料计算
                    if (string.IsNullOrWhiteSpace(cutHeadIds))
                    {
                        return response.ResponseError($"请选择工单！");
                    }
                    var result = Calculation(cutHeadIds);
                    if (result.Code != 200) return result;

                    #region 处理数据，转换为页面使用格式

                    /// 套料结果
                    List<TotalModel> totalModel = totalData.totalModel;
                    List<bus_cutplan_detail> cutplanDetail = new List<bus_cutplan_detail>();
                    foreach (var item in totalModel)
                    {
                        bus_cutplan_detail model = new bus_cutplan_detail();
                        model.keys = item.cutplanHead.keys;
                        model.workOrderHeadKeys = item.cutplanHead.keys;
                        model.parentTypeId = Guid.Parse("00000000-0000-0000-0000-000000000000");
                        model.materialCode = item.cutplanHead.materialCode;
                        model.lossCount = item.cutplanHead.lossCount;
                        model.pipeLength = item.cutplanHead.pipeLength;
                        model.oddmentsLength = item.cutplanHead.oddmentsLength;
                        model.nowWorkCenterCode = item.cutplanHead.nowWorkCenterCode;
                        model.nowWorkCenterName = item.cutplanHead.nowWorkCenterName;

                        cutplanDetail.Add(model);

                        item.planDetailList.ForEach(x =>
                        {

                            x.parentTypeId = item.cutplanHead.keys;

                            cutplanDetail.Add(x);

                        });
                    }

                    // 未套料工单头表
                    List<bus_workOrder_head> notWorkOrderheadList = totalData.notWorkOrderheadList;
                    // 未套料工单明细
                    List<bus_workOrder_detail> notWorkOrderDetailList = totalData.notWorkOrderDetailList;

                    //返回结果处理
                    List<bus_workOrder_detail> returnNotWorkOrderDetailList = new List<bus_workOrder_detail>();

                    foreach (var item in notWorkOrderheadList)
                    {

                        var nowDetail = Context.Queryable<bus_workOrder_detail>()
                                                   .Where(x => x.headKeys == item.keys && x.workCenterCode != EnumoprSequenceCode.套料)
                                                   .OrderBy(x => x.serialNumber, OrderByType.Asc).First();

                        //添加一个父对象，页面展示需要
                        bus_workOrder_detail workOrderDetail = new bus_workOrder_detail();
                        workOrderDetail.id = item.id;
                        workOrderDetail.keys = item.keys;
                        workOrderDetail.workOrderCode = item.workOrderCode;
                        workOrderDetail.nowWorkCenterCode = nowDetail.workCenterCode;
                        workOrderDetail.nowWorkCenterName = nowDetail.oprSequenceName;

                        workOrderDetail.parentTypeId = Guid.Parse("00000000-0000-0000-0000-000000000000");
                        returnNotWorkOrderDetailList.Add(workOrderDetail);

                        var DetailList = notWorkOrderDetailList.Where(x => x.headKeys == item.keys).ToList();
                        if (DetailList.Count > 0)
                        {
                            DetailList.ForEach(x =>
                            {
                                x.keys = Guid.NewGuid();
                                x.parentTypeId = item.keys;
                                returnNotWorkOrderDetailList.Add(x);
                            });
                        }
                    }

                    response.Message = "计算成功！";
                    response.Result = new
                    {
                        cutplanList = cutplanDetail,
                        notWorkOrderList = returnNotWorkOrderDetailList,
                        notInventoryList = totalData.notInventoryList
                    };

                    return response;

                    #endregion
                    #endregion
                }
            }
            catch (Exception ex)
            {
                return response.ResponseError($"套料计算发生异常，原因：{ex.Message}");
            }
        }

        /// <summary>
        /// 套料并且保存
        /// </summary>
        /// <param name="cutHeadIds">套料指定的工单头表ID</param>
        /// <returns></returns>
        public dynamic SaveCutPlan(string cutHeadIds)
        {
            var response = new Response();
            try
            {
                lock (LockNesting)
                {
                    #region 套料保存
                    if (string.IsNullOrWhiteSpace(cutHeadIds))
                    {
                        return response.ResponseError($"请选择工单！");
                    }
                    var result = Calculation(cutHeadIds);
                    if (result.Code != 200) return result;

                    if (totalData.totalModel.Count <= 0)
                    {
                        return response.ResponseError($"没有可以保存的套料方案！");
                    }

                    //工单头
                    List<bus_workOrder_head> workOrderHeadList = totalData.workOrderheadList;

                    //workOrderHeadList.ForEach(x =>
                    //{
                    //    x.nowOprSequenceCode = EnumoprSequenceCode.切割坡口;
                    //    x.nowStationCode = GetStation(EnumoprSequenceCode.切割坡口);
                    //    x.updateBy = SysUser;
                    //    x.updateTime = DateTime.Now;
                    //});

                    //更新工单头
                    //Context.Updateable(workOrderHeadList).UpdateColumns(t => new { t.nowOprSequenceCode, t.nowStationCode, t.updateBy, t.updateTime }).AddQueue();

                    //工单明细
                    List<bus_workOrder_detail> workOrderDetailList = totalData.workOrderDetailList;
                    //更新工单明细
                    Context.Updateable(workOrderDetailList).UpdateColumns(t => new { t.state, t.actualEndTime, t.updateBy, t.updateTime }).AddQueue();
                    //更新库存使用状态
                    Context.Updateable<base_inventory>()
                        .SetColumns(x => x.useState == (int)InventoryUseState.已套料)
                        .SetColumns(x => x.updateTime == DateTime.Now)
                        .Where(x => USEinventoryList.Contains(x.id)).AddQueue();


                    //套料结果
                    List<TotalModel> totalModel = totalData.totalModel;
                    foreach (var item in totalModel)
                    {
                        //添加套料结果
                        Context.Insertable(item.cutplanHead).AddQueue();
                        Context.Insertable(item.planDetailList).AddQueue();
                    }

                    var updateCount = ExecuteQueues(Context);
                    if (updateCount == 0)
                    {
                        return response.ResponseError($"套料方案方案保存数据库失败！");
                    }
                    else
                    {
                        //套料完工反馈
                        CutWeldService cutWeldService = new CutWeldService();

                        foreach (var item1 in totalModel)
                        {
                            foreach (var item2 in item1.planDetailList)
                            {
                                //工序完工反馈
                                cutWeldService.SendIWPTechnologylineProcess(item2.barCode, (int)EnumCutHeadState.已套料);
                            }
                        }
                    }

                    response.Message = "保存成功！";
                    return response;

                    #endregion
                }
            }
            catch (Exception ex)
            {
                return response.ResponseError($"套料保存发生异常，原因：{ex.Message}");
            }
        }

        /// <summary>
        /// 工位查询
        /// </summary>
        /// <param name="workCenterCode"></param>
        /// <returns></returns>
        public string GetStation(string workCenterCode)
        {
            return Context.Queryable<base_work_center_station_rel>().Where(x => x.workCenterCode == workCenterCode).First()?.workStationCode;
        }

        /// <summary>
        /// 手动完成套料方案，并且发送完工状态，也需要完成打磨工序
        /// </summary>
        /// <param name="ID">ID</param>
        /// <returns></returns>
        public dynamic CompleteExecute(int ID)
        {
            var response = new Response();
            try
            {
                lock (LockNesting)
                {
                    #region 手动完成套料方案

                    //获取套料方案头表
                    var cutPlanHead = Context.Queryable<bus_cutplan_head>().Where(t => t.id == ID).First();
                    if (cutPlanHead == null)
                    {
                        return response.ResponseError($"没有套料方案，请核对！");
                    }
                    if (cutPlanHead.state >= (int)EnumCutPlanHeadStatus.切割完成)
                    {
                        return response.ResponseError($"已经执行完成，不需要再次确认完成！");
                    }
                    //获取套料方案明细表
                    var cutPlanDetails = Context.Queryable<bus_cutplan_detail>().Where(t => t.headKeys == cutPlanHead.keys).ToList();
                    if (cutPlanDetails.Count == 0)
                    {
                        return response.ResponseError($"没有方案明细，请核对！");
                    }

                    #region 套料状态-手动完成

                    //把套料方案头改为 手动完成
                    cutPlanHead.state = (int)EnumCutPlanHeadStatus.手动完成;
                    cutPlanHead.actualEndTime = DateTime.Now.ToString();
                    cutPlanHead.cutEndTime = DateTime.Now.ToString();
                    cutPlanHead.updateBy = SysUser;
                    cutPlanHead.updateTime = DateTime.Now.ToString();
                    Context.Updateable(cutPlanHead).UpdateColumns(t => new { t.state, t.actualEndTime, t.cutEndTime, t.updateBy, t.updateTime }).AddQueue();

                    //把套料方案明细改为 切割完成
                    Context.Updateable<bus_cutplan_detail>()
                           .SetColumns(t => t.cutState == (int)EnumCutPlanDetailStatus.切割完成)
                           .SetColumns(t => t.cutEndTime == DateTime.Now.ToString())
                           .SetColumns(t => t.updateTime == DateTime.Now.ToString())
                           .SetColumns(t => t.updateBy == SysUser)
                           .Where(t => t.headKeys == cutPlanHead.keys)
                           .AddQueue();

                    //完成ECS行走方案 bus_cutorprint_plan
                    Context.Updateable<bus_cutorprint_plan>()
                          .SetColumns(t => t.state == (int)CutPlanHeadState.完成)
                          .SetColumns(t => t.updateTime == DateTime.Now)
                          .SetColumns(t => t.updateBy == SysUser)
                          .Where(t => t.headKeys == cutPlanHead.keys)
                          .AddQueue();


                    #endregion

                    #region 工单(切割,打磨)工序完成

                    //获取工单头表,如果工单头对应的明细实体都切割完毕，需要更新工单下一工序
                    var workOrderHeadList = cutPlanDetails.Select(x => x.workOrderHeadKeys).ToList().Distinct().ToList();
                    //本次完成的工单明细barCode
                    var barCodeList = cutPlanDetails.Select(x => x.barCode).ToList().Distinct().ToList();

                    //组对工序状态改为运输中
                    Context.Updateable<bus_workOrder_detail>()
                           .SetColumns(t => t.state == (int)EnumOrderBodyStatus.运输中)
                           .SetColumns(t => t.actualStartTime == DateTime.Now)
                           .SetColumns(t => t.updateTime == DateTime.Now)
                           .SetColumns(t => t.updateBy == SysUser)
                           .Where(t => barCodeList.Contains(t.barCode) && t.oprSequenceCode == EnumoprSequenceCode.组对)
                           .AddQueue();

                    //分工单处理
                    foreach (var item in workOrderHeadList)
                    {
                        #region 更新工单切割，打磨工序为完成

                        //套料工序工单明细
                        //var workOrderDetail = Context.Queryable<bus_workOrder_detail>().Where(x => x.headKeys == item && workOrderDetailList.Contains(x.bodyKeys)).ToList();
                        //已经套料工单明细barCode
                        //var barCodeList = workOrderDetail.Select(x => x.barCode).ToList().Distinct().ToList();

                        //更新工单明细切割，打磨工序为完成
                        Context.Updateable<bus_workOrder_detail>()
                           .SetColumns(t => t.state == (int)EnumOrderBodyStatus.已完成)
                           .SetColumns(t => t.actualStartTime == DateTime.Now)
                           .SetColumns(t => t.actualEndTime == DateTime.Now)
                           .SetColumns(t => t.updateTime == DateTime.Now)
                           .SetColumns(t => t.updateBy == SysUser)
                           .Where(t => t.headKeys == item && barCodeList.Contains(t.barCode) && (t.oprSequenceCode == EnumoprSequenceCode.切割坡口 || t.oprSequenceCode == EnumoprSequenceCode.打磨))
                           .AddQueue();
                        #endregion

                        #region 更新工单头是否到下一个工序
                        //工单头
                        var workOrderHead = Context.Queryable<bus_workOrder_head>().Where(x => x.keys == item).First();
                        //排除本次完成的切割工序明细
                        var cutplanDetail = Context.Queryable<bus_workOrder_detail>().Where(x => x.headKeys == item
                                                                                            && !barCodeList.Contains(x.barCode)
                                                                                            && x.state < (int)EnumOrderBodyStatus.已完成
                                                                                            && (x.oprSequenceCode == EnumoprSequenceCode.切割坡口 || x.oprSequenceCode == EnumoprSequenceCode.打磨)).ToList();

                        //排除本次完成的明细，切割，打磨工序都已经完成，就需要更新工单工序到下一工序
                        if (workOrderHead != null && cutplanDetail == null)
                        {
                            workOrderHead.nowOprSequenceCode = EnumoprSequenceCode.组对;
                            workOrderHead.nowStationCode = GetStation(EnumoprSequenceCode.组对);
                            workOrderHead.updateBy = SysUser;
                            workOrderHead.updateTime = DateTime.Now;

                            Context.Updateable(workOrderHead).UpdateColumns(t => new { t.nowOprSequenceCode, t.nowStationCode, t.updateBy, t.updateTime }).AddQueue();
                        }
                        #endregion
                    }

                    #endregion

                    //更新库存使用状态
                    Context.Updateable<base_inventory>()
                        .SetColumns(x => x.useState == (int)InventoryUseState.使用完毕)
                        .SetColumns(x => x.updateTime == DateTime.Now)
                        .Where(x => cutPlanHead.lotNo == x.pipeSN).AddQueue();


                    //打包执行处理
                    if (ExecuteQueues(Context) > 0)
                    {
                        //给上游完工反馈
                        CutWeldService cutWeldService = new CutWeldService();
                        cutPlanDetails.ForEach(x =>
                        {
                            cutWeldService.SendIWPTechnologylineProcess(x.barCode, (int)EnumCutHeadState.切坡完成);
                            cutWeldService.SendIWPTechnologylineProcess(x.barCode, (int)EnumCutHeadState.打磨完成);
                        }

                        );

                        return response;

                    }
                    else
                    {
                        return response.ResponseError($"手动完成套料方案数据库失败！");
                    }

                    #endregion
                }
            }
            catch (Exception ex)
            {
                return response.ResponseError($"手动完成发生异常，原因：{ex.Message}");
            }
        }

        /// <summary>
        /// 手动取消套料方案
        /// </summary>
        /// <param name="ID"></param>
        /// <returns></returns>
        public dynamic CancelPlan(int ID)
        {
            var response = new Response();
            try
            {
                lock (LockNesting)
                {
                    #region 手动取消套料方案
                    //获取套料方案头表
                    var cutPlanHead = Context.Queryable<bus_cutplan_head>().Where(t => t.id == ID).First();
                    if (cutPlanHead == null)
                    {
                        return response.ResponseError($"没有套料方案，请核对！");
                    }
                    if (cutPlanHead.state > (int)EnumCutPlanHeadStatus.初始)
                    {
                        return response.ResponseError($"已经开始执行或执行完成，不能取消！");
                    }
                    //获取套料方案明细表
                    var cutPlanDetails = Context.Queryable<bus_cutplan_detail>().Where(t => t.headKeys == cutPlanHead.keys).ToList();
                    if (cutPlanDetails.Count == 0)
                    {
                        return response.ResponseError($"没有方案明细，请核对！");
                    }

                    //删除套料方案头
                    Context.Deleteable<bus_cutplan_head>().Where(t => t.id == ID).AddQueue();
                    //删除套料方案明细
                    Context.Deleteable<bus_cutplan_detail>().Where(t => t.headKeys == cutPlanHead.keys).AddQueue();

                    //获取工单头表
                    var workOrderHead = cutPlanDetails.GroupBy(x => x.workOrderHeadKeys).Select(x => x.Key.ToString()).ToList();

                    //把工单改为套料工序
                    Context.Updateable<bus_workOrder_head>()
                           .SetColumns(t => t.nowOprSequenceCode == EnumoprSequenceCode.套料)
                           .SetColumns(t => t.nowStationCode == GetStation(EnumoprSequenceCode.套料))
                           .SetColumns(t => t.updateTime == DateTime.Now)
                           .SetColumns(t => t.updateBy == SysUser)
                           .Where(t => workOrderHead.Contains(t.keys.ToString()))
                           .AddQueue();

                    //工单套料工序明细状态改为初始
                    var workOrderDetails = cutPlanDetails.Select(x => x.workOrderDetailKeys).ToList();
                    Context.Updateable<bus_workOrder_detail>()
                           .SetColumns(t => t.state == (int)EnumOrderBodyStatus.初始化)
                           .SetColumns(t => t.updateTime == DateTime.Now)
                            .SetColumns(t => t.updateBy == SysUser)
                           .Where(t => workOrderDetails.Contains(t.bodyKeys))
                           .AddQueue();

                    //更新库存使用状态
                    Context.Updateable<base_inventory>()
                        .SetColumns(x => x.useState == (int)InventoryUseState.未套料)
                        .SetColumns(x => x.updateTime == DateTime.Now)
                        .Where(x => cutPlanHead.lotNo == x.pipeSN).AddQueue();

                    //打包执行处理
                    if (ExecuteQueues(Context) > 0)
                    {
                        //反馈上游套料取消

                        return response;
                    }
                    else
                    {
                        return response.ResponseError($"手动完成套料方案数据库失败！");
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            {
                return response.ResponseError($"手动取消发生异常，原因：{ex.Message}");
            }
        }

        #endregion
    }

}