更新通讯源码

qiuyao

2025-03-24 45045dab394abe534fa5221a1e09a90c1eebf835

 ÏîÄ¿´úÂë/WIDESEAWCS_Server Õýʽ/SerialPortService/ProcessServer.cs

@@ -1,11 +1,16 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using AutoMapper;
using AutoMapper.Configuration.Conventions;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using SqlSugar;
using WIDESEA_ISerialPortRepository;
using WIDESEA_SerialPortRepository;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Core.BaseServices;
@@ -16,142 +21,376 @@
namespace WIDESEAWCS_TaskInfoService
{
    public class ProcessServer : ServiceBase<Dt_Process, IProcessRepository>, IProcessServer
    { 
        
    {
        private IPutakeRepository _putakeRepository;
        private IUnitOfWorkManage _unitOfWorkManage;
        public ProcessServer(IProcessRepository BaseDal, IUnitOfWorkManage unitOfWorkManage) : base(BaseDal)
        private ITorqueOpRepository _torqueOpRepository;
        private readonly IMapper _mapper;

        public ProcessServer(IProcessRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IPutakeRepository putakeRepository, ITorqueOpRepository torqueOpRepository, IMapper mapper) : base(BaseDal)
        {
            _unitOfWorkManage=unitOfWorkManage;
            _putakeRepository = putakeRepository;
            _unitOfWorkManage = unitOfWorkManage;
            _torqueOpRepository = torqueOpRepository;
            _mapper = mapper;
        }

     
        public override PageGridData<Dt_Process> GetPageData(PageDataOptions options)
        {
            OrderByParameters = new Dictionary<string, OrderByType>
            {
                { nameof(Dt_Process.SetpNum), OrderByType.Asc },//按什么字段排序
                 { nameof(Dt_Process.CraftType), OrderByType.Asc }
            };
            return base.GetPageData(options);
        }

        public WebResponseContent GetProcess(string gruop)
        /// <summary>
        /// èŽ·å–套筒数量
        /// </summary>
        /// <returns>返回班组、总步骤、套筒数量</returns>
        public WebResponseContent GetSleeveandStep()
        {
            try
            {
                _unitOfWorkManage.BeginTran();
                var proce = BaseDal.QueryData(i => i.CraftType == gruop);


                _unitOfWorkManage.CommitTran();
                if (proce != null)
                {
                    return new WebResponseContent { Status = true, Data = proce };
                }
                else
                {
                    return new WebResponseContent{ Status = false, Message = "数据为空"};
                }

            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return new WebResponseContent { Status = false, Message = "失败" + ex.Message };
            }
        }

        public WebResponseContent GetSleeveandStep(string gruops)
        {
            try
            {
                _unitOfWorkManage.BeginTran();
                var result = BaseDal.QueryData(x => x.CraftType == gruops) // å…ˆç­›é€‰ CraftType
                var result = BaseDal.QueryData() // å…ˆæŸ¥å‡ºå…¨éƒ¨
                    .GroupBy(x => x.CraftType) // æŒ‰ CraftType åˆ†ç»„
                    .Select(g => new
                    {
                       maxNodal = g.Max(a=>a.Nodal),
                        sumTorqueSum = g.Sum(a=>a.TorqueSum)
                        //尽量后端数据给前端的数据，调一次接口就可以拿到，不要让前端多次调用
                        CraftType = g.Key, // æ·»åŠ  CraftType
                        maxNodal = g.Max(a => a.Nodal),//最大步骤
                        sumTorqueSum = g.Sum(a => a.TorqueSum),//套筒数量
                    }).ToList();
                _unitOfWorkManage.CommitTran() ;

                return new WebResponseContent { Status = true, Data = result };
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return new WebResponseContent { Status = false, Message = "查询失败：" + ex.Message };
            }
        }


        public WebResponseContent AddProcess(AddProcessDTO addProcessDTO)
        {
            try
            {
                var proces = new Dt_Process();
                proces.Nodal=addProcessDTO.nodal;
                proces.CraftType=addProcessDTO.craftstype;
                proces.CraftsStep=addProcessDTO.craftsstep;
                proces.CraftContent=addProcessDTO.craftcontent;
                proces.TorqueSum = addProcessDTO.sleeveNum;
                proces.Tools=addProcessDTO.tools;
                _unitOfWorkManage.BeginTran() ;
                BaseDal.AddData(proces);
                _unitOfWorkManage.CommitTran();
                return new WebResponseContent { Status = true,Data=proces};
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran() ;
                return new WebResponseContent { Status = false, Message = "查询失败：" + ex.Message };
            }
        }
        #region
        //public WebResponseContent AddOrUpdateProcess(AddProcessDTO addProcessDTO)
        //{
        //    try
        //    {
        //        var allProcesses = BaseDal.QueryData(); // ä»…查询一次所有数据

        public WebResponseContent Upprocess(PutProcessDTO addProcessDTO)
        //        if (addProcessDTO.id == 0) // æ·»åŠ 
        //        {
        //            // æ£€æŸ¥æ˜¯å¦å·²ç»å­˜åœ¨ç›¸åŒçš„ setnum
        //            if (allProcesses.Any(x => x.SetpNum == addProcessDTO.setnum && x.CraftType == addProcessDTO.craftstype))
        //            {
        //                return new WebResponseContent { Status = false, Message = $"步骤 {addProcessDTO.setnum} å·²å­˜åœ¨ï¼Œä¸èƒ½é‡å¤æ·»åŠ ï¼" };
        //            }

        //            // åˆ›å»ºæ–°å·¥è‰ºæ­¥éª¤
        //            var proces = new Dt_Process
        //            {
        //                SetpNum = addProcessDTO.setnum,
        //                CraftType = addProcessDTO.craftstype,
        //                CraftsStep = addProcessDTO.craftsstep,
        //                CraftContent = addProcessDTO.craftcontent,
        //                Tools = addProcessDTO.tools,
        //                Material = addProcessDTO.material,
        //                ArticleOneid = addProcessDTO.aritcleoneid,
        //                ArticleOne = addProcessDTO.articleone,
        //                ArticleTowid = addProcessDTO.aritcletowid,
        //                ArticleTwo = addProcessDTO.articletwo,
        //                CreateDate = DateTime.Now
        //            };

        //            BaseDal.AddData(proces);
        //            return new WebResponseContent { Status = true, Data = proces };
        //        }
        //        else // æ›´æ–°
        //        {
        //            var existingProcess = allProcesses.FirstOrDefault(x => x.CraftID == addProcessDTO.id);
        //            if (existingProcess == null)
        //            {
        //                return new WebResponseContent { Status = false, Message = "未找到该工艺步骤，无法更新！" };
        //            }

        //            // åªæœ‰å½“ setnum å‘生变化时，才进行重复性检查
        //            if (existingProcess.SetpNum != addProcessDTO.setnum && allProcesses.Any(x => x.SetpNum == addProcessDTO.setnum && x.CraftType == addProcessDTO.craftstype && x.CraftID != addProcessDTO.id))
        //            {
        //                return new WebResponseContent { Status = false, Message = $"步骤 {addProcessDTO.setnum} å·²å­˜åœ¨ï¼Œä¸èƒ½é‡å¤ï¼" };
        //            }

        //            // æ›´æ–°æ•°æ®
        //            existingProcess.Nodal = addProcessDTO.Nodal;
        //            existingProcess.SetpNum = addProcessDTO.setnum;
        //            existingProcess.CraftType = addProcessDTO.craftstype;
        //            existingProcess.CraftsStep = addProcessDTO.craftsstep;
        //            existingProcess.CraftContent = addProcessDTO.craftcontent;
        //            existingProcess.Tools = addProcessDTO.tools;
        //            existingProcess.Material = addProcessDTO.material;
        //            existingProcess.ArticleOneid = addProcessDTO.aritcleoneid;
        //            existingProcess.ArticleOne = addProcessDTO.articleone;
        //            existingProcess.ArticleTowid = addProcessDTO.aritcletowid;
        //            existingProcess.ArticleTwo = addProcessDTO.articletwo;
        //            existingProcess.CreateDate = DateTime.Now;

        //            BaseDal.UpdateData(existingProcess);
        //            return new WebResponseContent { Status = true, Data = existingProcess };
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        return new WebResponseContent { Status = false, Message = "操作失败：" + ex.Message };
        //    }
        //}




        //获取当前任务工作步骤
        #endregion

        /// <summary>
        /// æ ¹æ®id来判断，有id就更新没有就添加
        /// </summary>
        /// <param name="addProcessDTO"></param>
        /// <returns></returns>
        public WebResponseContent AddOrUpdateProcess(AddProcessDTO addProcessDTO)
        {
            try
            {
                var proces = BaseDal.QueryData(x => x.CraftID == addProcessDTO.id).FirstOrDefault();
                    if (proces == null)
                var allProcesses = BaseDal.QueryData().OrderBy(x => x.SetpNum).ToList(); // æŒ‰ SetpNum æŽ’序
                Dt_Process proces = _mapper.Map<Dt_Process>(addProcessDTO);

                #region æ·»åŠ 
                if (addProcessDTO.CraftID == 0) // æ·»åŠ 
                {
                    return new WebResponseContent { Status = false,Message="没有找到"};
                }
                proces.Nodal = addProcessDTO.nodal;
                proces.CraftType = addProcessDTO.craftstype;
                proces.CraftsStep = addProcessDTO.craftsstep;
                proces.CraftContent = addProcessDTO.craftcontent;
                proces.TorqueSum = addProcessDTO.sleeveNum;
                proces.Tools = addProcessDTO.tools;
                _unitOfWorkManage.BeginTran();
                BaseDal.UpdateData(proces);
                _unitOfWorkManage.CommitTran();
                return new WebResponseContent { Status = true, Data = proces };
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return new WebResponseContent { Status = false, Message = "查询失败：" + ex.Message };
            }
        }
                    //// æ£€æŸ¥æ˜¯å¦å·²ç»å­˜åœ¨ç›¸åŒçš„ SetpNum
                    //if (allProcesses.Any(x => x.SetpNum == addProcessDTO.setpNum && x.CraftType == addProcessDTO.craftstype))
                    //{
                    //    return new WebResponseContent { Status = false, Message = $"步骤 {addProcessDTO.setpNum} å·²å­˜åœ¨ï¼Œä¸èƒ½é‡å¤æ·»åŠ ï¼" };
                    //}

        public WebResponseContent Getcircuit(string groups)
        {
            try
            {
                List<Dt_Process> results = new List<Dt_Process>();
                int step = 1;
                    //// éœ€è¦è°ƒæ•´åŽç»­æ­¥éª¤çš„序号
                    //foreach (var process in allProcesses.Where(x => x.SetpNum >= addProcessDTO.setpNum))
                    //{
                    //    process.SetpNum++; // åŽç§»ä¸€ä½
                    //    BaseDal.UpdateData(process);
                    //}

                while (true)
                {
                    // æŸ¥è¯¢å½“前步骤的数据
                    var circuit = BaseDal.QueryData(x => x.CraftType == groups && x.SetpNum == step)
                                         .FirstOrDefault();
                    // éœ€è¦è°ƒæ•´åŽç»­æ­¥éª¤çš„序号
                    var processList = allProcesses.Where(x => x.SetpNum >= addProcessDTO.SetpNum).ToList();

                    // å¦‚果查询结果为空，则停止循环
                    if (circuit == null)
                    if (processList != null)
                    {
                        break;
                        for (int i = 0; i < processList.Count; i++)
                        {
                            processList[i].SetpNum += 1;
                        }
                    }

                    // åŠ å…¥ç»“果列表
                    results.Add(circuit);
                    // åˆ›å»ºæ–°å·¥è‰ºæ­¥éª¤
                    
                    proces.TorqueSum = (string.IsNullOrEmpty(addProcessDTO.ArticleOne) ? 0 : 1) + (string.IsNullOrEmpty(addProcessDTO.ArticleTwo) ? 0 : 1);
                    proces.CreateDate = DateTime.Now;

                    // é€’增 step，继续查询下一个步骤
                    step++;
                    //var proces = new Dt_Process
                    //{
                    //    Nodal = addProcessDTO.Nodal,
                    //    SetpNum = addProcessDTO.setpNum,
                    //    CraftType = addProcessDTO.craftstype,
                    //    CraftsStep = addProcessDTO.craftsstep,
                    //    CraftContent = addProcessDTO.craftcontent,
                    //    Tools = addProcessDTO.tools,
                    //    Material = addProcessDTO.material,
                    //    ArticleOneid = addProcessDTO.aritcleoneid,
                    //    ArticleOne = addProcessDTO.articleone,
                    //    ArticleTowid = addProcessDTO.aritcletowid,
                    //    ArticleTwo = addProcessDTO.articletwo,
                    //    CreateDate = DateTime.Now,
                    //    PointAxisXYZ = addProcessDTO.PointAxisXYZ,
                    //    PointAxisHPB = addProcessDTO.PointAxisHPB,
                    //    //为空就是0，不为空就是1
                    //    TorqueSum = (string.IsNullOrEmpty(addProcessDTO.articleone) ? 0 : 1) + (string.IsNullOrEmpty(addProcessDTO.articletwo) ? 0 : 1)
                    //};

                    _unitOfWorkManage.BeginTran();
                    BaseDal.AddData(proces);
                    BaseDal.UpdateData(processList);
                    _unitOfWorkManage.CommitTran();
                    return new WebResponseContent { Status = true, Data = proces };
                }
                #endregion
                #region ä¿®æ”¹
                else // æ›´æ–°
                {
                    var existingProcess = allProcesses.FirstOrDefault(x => x.CraftID == addProcessDTO.CraftID);
                    if (existingProcess == null)
                    {
                        return new WebResponseContent { Status = false, Message = "未找到该工艺步骤，无法更新！" };
                    }

                    int oldSetNum = existingProcess.SetpNum;
                    int newSetNum = addProcessDTO.SetpNum;

                    if (existingProcess.SetpNum == addProcessDTO.SetpNum) // å¦‚果没改顺序，直接更新其他内容
                    {
                        proces.TorqueSum = (string.IsNullOrEmpty(addProcessDTO.ArticleOne) ? 0 : 1) + (string.IsNullOrEmpty(addProcessDTO.ArticleTwo) ? 0 : 1);
                        proces.ModifyDate = DateTime.Now;

                        //existingProcess.Nodal = addProcessDTO.Nodal;
                        //existingProcess.CraftType = addProcessDTO.craftstype;
                        //existingProcess.CraftsStep = addProcessDTO.craftsstep;
                        //existingProcess.CraftContent = addProcessDTO.craftcontent;
                        //existingProcess.Tools = addProcessDTO.tools;
                        //existingProcess.Material = addProcessDTO.material;
                        //existingProcess.ArticleOneid = addProcessDTO.aritcleoneid;
                        //existingProcess.ArticleOne = addProcessDTO.articleone;
                        //existingProcess.ArticleTowid = addProcessDTO.aritcletowid;
                        //existingProcess.ArticleTwo = addProcessDTO.articletwo;
                        //existingProcess.CreateDate = DateTime.Now;
                        //existingProcess.TorqueSum = (string.IsNullOrEmpty(addProcessDTO.articleone) ? 0 : 1) + (string.IsNullOrEmpty(addProcessDTO.articletwo) ? 0 : 1);

                        BaseDal.UpdateData(proces);
                        return new WebResponseContent { Status = true, Data = proces };
                    }
                    // æ›´æ–° TorqueSum

                    // è°ƒæ•´é¡ºåº
                    if (newSetNum < oldSetNum) // å‘前移动，后续数据往后移
                    {
                        var processList = allProcesses.Where(x => x.SetpNum >= newSetNum && x.SetpNum < oldSetNum).ToList();

                        for (int i = 0; i < processList.Count; i++)
                        {
                            processList[i].SetpNum += 1;
                        }

                        BaseDal.UpdateData(processList);
                        //foreach (var process in allProcesses.Where(x => x.SetpNum >= newSetNum && x.SetpNum < oldSetNum))
                        //{
                        //    process.SetpNum++; // åŽç§»ä¸€ä½
                        //    BaseDal.UpdateData(process);
                        //}
                    }
                    else if (newSetNum > oldSetNum) // å‘后移动，前面数据往前移
                    {
                        var processList = allProcesses.Where(x => x.SetpNum > oldSetNum && x.SetpNum <= newSetNum).ToList();

                        for (int i = 0; i < processList.Count; i++)
                        {
                            processList[i].SetpNum -= 1;
                        }

                        BaseDal.UpdateData(processList);

                        //foreach (var process in allProcesses.Where(x => x.SetpNum > oldSetNum && x.SetpNum <= newSetNum))
                        //{
                        //    process.SetpNum--; // å‰ç§»ä¸€ä½
                        //    BaseDal.UpdateData(process);
                        //}
                    }

                    proces.SetpNum = newSetNum;
                    proces.TorqueSum = (string.IsNullOrEmpty(addProcessDTO.ArticleOne) ? 0 : 1) + (string.IsNullOrEmpty(addProcessDTO.ArticleTwo) ? 0 : 1);
                    proces.ModifyDate = DateTime.Now;

                    //// æ›´æ–°å½“前步骤的新序号
                    //existingProcess.SetpNum = newSetNum;
                    //existingProcess.Nodal = addProcessDTO.Nodal;
                    //existingProcess.CraftType = addProcessDTO.craftstype;
                    //existingProcess.CraftsStep = addProcessDTO.craftsstep;
                    //existingProcess.CraftContent = addProcessDTO.craftcontent;
                    //existingProcess.Tools = addProcessDTO.tools;
                    //existingProcess.Material = addProcessDTO.material;
                    //existingProcess.ArticleOneid = addProcessDTO.aritcleoneid;
                    //existingProcess.ArticleOne = addProcessDTO.articleone;
                    //existingProcess.ArticleTowid = addProcessDTO.aritcletowid;
                    //existingProcess.ArticleTwo = addProcessDTO.articletwo;
                    //existingProcess.CreateDate = DateTime.Now;

                    BaseDal.UpdateData(proces);
                    return new WebResponseContent { Status = true, Data = proces };
                }
                #endregion
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "操作失败：" + ex.Message };
            }
        }


        public WebResponseContent Getcircuit(string group, string takeid)
        {
            try
            {
                Dt_Process proNow = new Dt_Process();
                //根据组和任务号获得torqueOp表全部数据
                var torp = _torqueOpRepository.QueryData(x => x.GroupOp == group && x.TakeId == takeid);


                //获取Modifier  ="true"  è¡¨ç¤ºæ˜¯å¼ºåˆ¶æ‰§è¡Œ
                //var Mod = torp.Select(x => x.Modifier).FirstOrDefault();

                //查出工艺表
                var process = BaseDal.QueryData(x => x.CraftType == group);

                //返回当前工艺的最大步骤
                var maxproce = process.Max(x => x.SetpNum);


                //拿到工艺表中步骤为1的
                //var proNoe = process.Where(x => x.SetpNum == 1);//获得工艺表中的第一步
                if (torp.Count == 0)
                {
                    proNow = process.Where(x => x.SetpNum == 1).First();
                    return new WebResponseContent { Status = true, Message = "返回工艺表中的第一条", Data = new { proNow, maxproce } };
                }

                return new WebResponseContent { Status = true, Data = results };
                var nowNum = torp.Max(x => x.ProcessSte);//获得当前最大步骤
                var flag = torp.Where(a => a.ProcessSte == nowNum && a.Modifier == "true").FirstOrDefault();
                //op.Modifier="true"  è¡¨ç¤ºæ˜¯å¼ºåˆ¶æ‰§è¡Œï¼Œå°±ä¸éœ€è¦åˆ¤æ–­åº”扭的次数，直接返回 op.ProcessSte+1
                //if (Mod == "true")
                //{
                //    var now = maxproce + 1;
                //    return new WebResponseContent { Status = true, Data = new { proNoe, maxproce, now } };
                //}
                if (flag != null)
                {
                    var now = maxproce + 1;
                    proNow = process.Where(x => x.SetpNum == now).First();
                    var finish= process.Where(x => x.SetpNum > now);
                    return new WebResponseContent { Status = true, Data = new { proNow, maxproce, now, finish } };
                }

                //如果存值表中有数据就返回给他当前工艺步骤
                var maxpro = process.Where(x => x.SetpNum == nowNum).FirstOrDefault();
                if (maxpro != null)
                {
                    if (maxpro.TorqueOneQuantity + maxpro.TorqueTwoQuantity > torp.Where(a => a.ProcessSte == nowNum).Count())
                    {
                        proNow = maxpro;
                        var finish = process.Where(x => x.SetpNum < nowNum);
                        return new WebResponseContent { Status = true, Message = "返回当前任务做到的大步骤", Data = new { proNow, maxproce, finish } };
                    }
                    else
                    {
                        var now = nowNum + 1;
                        proNow = process.Where(x => x.SetpNum == now).First();
                        var finish = process.Where(x => x.SetpNum < now);
                        return new WebResponseContent { Status = true, Message = "返回当前任务做到的大步骤", Data = new { proNow, maxproce, finish } };
                    }
                }
                else
                {
                    return new WebResponseContent { Status = false, Message = "工艺数据有误"};
                }

                //判断当前步骤的扭力次数是否完成，没完成返回当前步骤，完成返回op.ProcessSte+1，状态值给false   

                //return new WebResponseContent { Status = true, Message = "返回当前任务做到的大步骤", Data = new { maxpro, maxproce } };

            }
            catch (Exception ex)
            {
@@ -159,7 +398,124 @@
            }
        }

       
        /// <summary>
        /// å·¥è‰ºä¸‹ä¸€æ­¥è·³è½¬
        /// </summary>
        /// <param name="setpDTO">当前班组的任务当前步骤</param>
        /// <param name="flag">是否强制执行；是true，否false</param>
        /// <returns>返回1、当前步骤；2、最大步骤；3、已完成的工艺</returns>
        public WebResponseContent Nextprocess(SetpDTO setpDTO, bool flag)//强制执行给我true
        {
            try
            {
                Dt_TorqueOp op = new Dt_TorqueOp();
                //查出工艺表
                var process = BaseDal.QueryData(x => x.CraftType == setpDTO.group);

                // æŸ¥è¯¢å½“前步骤的 TorqueOp è®°å½•ï¼ŒåŒ¹é… ProcessSte和组，任务号，检查是否达到要求（实际数量）
                int practiceCount = _torqueOpRepository.QueryData(x => x.ProcessSte == setpDTO.setnum && x.GroupOp == setpDTO.group && x.TakeId == setpDTO.takeid).Count();

                //查到有该条数据了(更具分组和步骤找到该条数据)
                var nowdate = process.Where(x => x.CraftType == setpDTO.group && x.SetpNum == setpDTO.setnum);

                //返回当前工艺的最大步骤
                var maxproce = process.Max(x => x.SetpNum);

                var TorqueOneQuantity = nowdate.Select(x => x.TorqueOneQuantity).FirstOrDefault();
                var TorqueTwoQuantity = nowdate.Select(x => x.TorqueTwoQuantity).FirstOrDefault();

                //判断存值表的数据是否满足该步骤需要几条数据的条数
                int TargetCount = TorqueOneQuantity + TorqueTwoQuantity;//一共要有多少条数据（目标数量）

                if (practiceCount < TargetCount && !flag)
                {
                    return new WebResponseContent { Status = true, Message = "没有完成当前步骤", Data = new { nowdate, maxproce } };
                }
                else if ((practiceCount == TargetCount && TargetCount == 0) || (practiceCount != TargetCount && flag))//强制执行 å‰ç«¯ç»™æˆ‘一个flag=ture时
                {
                    //强制跳转下一步，插入op表当前步骤
                    op.TakeId = setpDTO.takeid;
                    op.GroupOp = setpDTO.group;
                    op.ProcessSte = setpDTO.setnum;
                    op.CreateDate = DateTime.Now;
                    op.Creater = "admin";
                    op.Modifier = "true";
                }

                if (maxproce == setpDTO.setnum)
                {
                    return new WebResponseContent { Status = false, Message = "你完成了当前作业" };
                }
                int num = setpDTO.setnum + 1;

                //返回下一步步骤
                var nex = process.Where(x => x.SetpNum == num).FirstOrDefault();
                var finish = process.Where(x => x.SetpNum < num).ToList();

                _torqueOpRepository.AddData(op);
                return new WebResponseContent { Status = true, Message = $"你已完成当前第{setpDTO.setnum}，准备第{num}步任务", Data = new { nex, maxproce, finish } };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "查询失败：" + ex.Message };
            }
        }


        public WebResponseContent PreviousProcess(SetpDTO setpDTO)
        {
            try
            {
                //查出工艺表
                var process = BaseDal.QueryData(x => x.CraftType == setpDTO.group);

                // æŸ¥è¯¢å½“前步骤的 TorqueOp è®°å½•ï¼ŒåŒ¹é… ProcessSte和组，任务号，检查是否达到要求（实际数量）
                int practiceCount = _torqueOpRepository.QueryData(x => x.ProcessSte == setpDTO.setnum && x.GroupOp == setpDTO.group && x.TakeId == setpDTO.takeid).Count();
                //查到有该条数据了(更具分组和步骤找到该条数据)
                var nowdate = process.Where(x => x.CraftType == setpDTO.group && x.SetpNum == setpDTO.setnum);

                //返回当前工艺的最大步骤
                var maxproce = process.Max(x => x.SetpNum);
                int num = setpDTO.setnum - 1;
                var nex = process.Where(x => x.CraftType == setpDTO.group && x.SetpNum == num).FirstOrDefault();
                var finish = process.Where(x => x.SetpNum < num).ToList();
                return new WebResponseContent { Status = true, Message = $"上一步{setpDTO.setnum}", Data = new { nex, maxproce, finish } };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "查询失败：" + ex.Message };
            }
        }

        /// <summary>
        /// è¯»å–当前工艺步骤的扭力值与次数
        /// </summary>
        /// <param name="grop"></param>
        /// <param name="setnum"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent GetValueandNumber(string grop, int setnum)
        {
            try
            {
                var result = BaseDal.QueryData(x => x.CraftType == grop && x.SetpNum == setnum)
                    .Select(g => new
                    {
                        g.TorqueOne,
                        g.TorqueOneQuantity,
                        g.TorqueTwo,
                        g.TorqueTwoQuantity
                    });
                return new WebResponseContent { Status = true, Data = result }; 
              
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false,Message="错误："+ex }; throw;
            }
        }
    }


}