修复查询bug

schangxiang@126.com

2025-05-21 0e42f871905f207658d822fcbe29aeb57b2156af

修复查询bug

 PipeLineLems/pipelinelems_web/src/widgets/PipeAccessoryAssembly/Controllers/PipeAccessoryAssembly.ts

@@ -142,6 +142,40 @@
    }, 
  ] 
 

  //下发法兰冲码
  const onSendFlangeCode = () => { 
    const names = selection.value.map((item: { dataIdentifier: string }) => item.dataIdentifier) 
    if(names.length==0){
      ElMessage.warning('请选择一条记录');
      return;
    }
    if(names.length>1){
      ElMessage.warning('请只能选择一条记录');
      return;
    }
    ConfirmBox( 
      `是否要下发法兰冲码${names.length ? names.join(',') : ''}` 
    ).then(async () => { 
      // èŽ·å–选中的第一条记录
  const selectedItem = selection.value[0];
  
  // æž„建参数对象
  const param = {
    Son_TaskCode: selectedItem.son_TaskCode || '',  // å­ä»»åŠ¡ç¼–号
    TaskCode: selectedItem.taskCode || '',        // ä»»åŠ¡ç¼–号
    PipeSpecCode: selectedItem.pipeSpecCode || '',// ç®¡æ®µç¼–码
  };

     var ret= await PipeAccessoryAssembly.sendFlangeCode(param) 
      if(ret.code=="200"){
        ElMessage.success('下发成功') 
        tableRef.value.getList() 
      }else{
        ElMessage.error('下发失败:'+ret.message) 
      }
    }) 
  } 
  const onCheck = (records: any) => { 
    selection.value = records 
  } 
@@ -270,6 +304,7 @@
    onConfirmPipeAccessoryAssembly, 
    onCheck, 
    onAddPipeAccessoryAssembly, 
    onAdvancedQuery 
    onAdvancedQuery,
    onSendFlangeCode 
  } 
} 

 PipeLineLems/pipelinelems_web/src/widgets/PipeAccessoryAssembly/Models/PipeAccessoryAssembly.ts

@@ -2,6 +2,7 @@
import { 
  // deletePipeAccessoryAssemblys, 
  // addPipeAccessoryAssembly, 
  sendFlangeCode,
  cloneData, 
} from './Service/PipeAccessoryAssembly' 
 
@@ -20,7 +21,14 @@
  async deletePipeAccessoryAssemblys(ids: string[]) { 
   // return deletePipeAccessoryAssemblys(ids) 
  } 
 
  /** 
   * ä¸‹å‘法兰冲码 
   * @param id 
   * @returns 
   */ 
  async sendFlangeCode(data: Record<string, any>) { 
    return sendFlangeCode(data) 
   } 
  /** 
   * æ·»åŠ æ•°æ® 
   * @param data 

 PipeLineLems/pipelinelems_web/src/widgets/PipeAccessoryAssembly/Models/Service/PipeAccessoryAssembly.ts

@@ -76,4 +76,12 @@
 */
export const finishProduction  = (data: any) => {
  return request.post('/api/v1/PipeLineLems/WorkPlanPublic/finishProduction', data)
}

/**
 * ä¸‹å‘法兰冲码
 * @returns
 */
export const sendFlangeCode  = (data: any) => {
  return request.post('/api/v1/PipeLineLems/WorkPlanPublic/sendFlangeCode', data)
}

 PipeLineLems/pipelinelems_web/src/widgets/PipeAccessoryAssembly/Views/Pages/PipeAccessoryAssembly/PipeAccessoryAssembly.tsx

@@ -62,6 +62,7 @@
      openDetail,
      onSuccess,
      onBeforeUpload,
      onSendFlangeCode
    } = usePipeAccessoryAssembly(props, ctx)

    // æŸ¥è¯¢è¡¨å•æ•°æ®
@@ -196,6 +197,15 @@
      routeUrl.value="/api/v1/PipeLineLems/workTask/page";
      paramForProcessRoute.pipeSpecCode = queryForm.value.pipeSpecCode
      tableRef.value.getList(paramForProcessRoute)  
    }
     // ä¸‹å‘法兰冲码
     const sendFlangeCode = () => {
      console.log('执行 ä¸‹å‘法兰冲码')
      if (queryForm.value.pipeSpecCode == '') {
        ElMessage.error('请输入管段编码')
        return
      }
       onSendFlangeCode();
    }
    // å¼€å·¥äº‹ä»¶å¤„理
    const startWork = () => {
@@ -539,10 +549,13 @@
          </div> */}
          <div class="info-block">
            <h2 class="block-title">工艺信息</h2>
            <div class={styles.actionButtons}>
            <div class={styles.actionButtons} style="margin-bottom:5px;">
              <ElButton type="warning" onClick={refreshProcessRoute}>
                åˆ·æ–°
              </ElButton>
              <ElButton type="warning" onClick={sendFlangeCode}>
                ä¸‹å‘法兰冲码
              </ElButton>
            </div>
            <RenderBaseTable
              url={routeUrl.value}

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems.Application.Contracts/Dtos/WorkPlan/SendFlangeCodeInput.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkPlan
{
    /// <summary>
    /// ä¸‹å‘法兰冲码 è¾“入参数模型
    /// </summary>
    [Serializable]
    public class SendFlangeCodeInput
    {

        /// <summary>
        /// å­ä»»åŠ¡ç¼–号
        /// </summary>
        public string Son_TaskCode { get; set; }

        /// <summary>
        /// ä»»åŠ¡ç¼–号
        /// </summary>
        public string TaskCode { get; set; }
       
    }
}

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems.Application/Implements/SharedService.cs

@@ -21,6 +21,7 @@
using CmsQueryExtensions;
using CmsQueryExtensions.Entitys;
using CmsQueryExtensions.Extension;
using Humanizer;
using KissUtil.Extensions;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
@@ -35,6 +36,8 @@
/// </summary> 
public class SharedService : CMSPluginAppService
{



    /// <summary>
    /// åˆ†æ‹£åŠŸèƒ½
@@ -813,7 +816,7 @@


    /// <summary>
    /// è£…配工序完工
    /// è£…配/焊接工序完工
    /// </summary>
    /// <param name="_serviceProvider"></param>
    /// <param name="input"></param>
@@ -833,69 +836,7 @@
        }


        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
        var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
        var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
        var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
        var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
        var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
        var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        string processName = "";
        var firstWorkTask = await workTaskAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
        if (firstWorkTask == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }
        //物料参数列表
        var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
        if (firstWorkPlan == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }
        if (firstWorkPlan.ProcessName == "装配工序")
        {
            processName = "装配";
        }
        else if (firstWorkPlan.ProcessName == "焊接工序")
        {
            processName = "焊接";
        }

        await CompleteHandleOutStoreFinish(_serviceProvider, processName, true);

        //根据工序名获取工序对象
        var workSection = await _workSectionManager.GetByNameAsync($"{processName}工序");
        var workStation = await _workStationManager.GetByNameAsync($"{processName}工位");
        //写入追溯报表
        var finishTime = DateTime.Now;
        TraceModel traceModel = new TraceModel()
        {
            SerialNumber = input.PipeSpecCode,
            WorkSectionId = workSection.Id,
            WorkSectionName = workSection.Name,
            WorkStationName = workStation.Name,

            FinishTime = finishTime,
            IsQualified = true,
            UnqualifiedReason = "",
            ProductModel = "",
            ProductName = "",

        };
        traceModel.Params = new List<TraceParamModel>();
        foreach (var item in workSection.ProcessParameters)
        {
            var value = "ssss";
            traceModel.Params.Add(new TraceParamModel()
            {
                Key = item.Key,
                Value = value.SafeString()
            });
        }

        #region äº‹åŠ¡

@@ -906,6 +847,70 @@
        try
        {
            #region æ•°æ®å¤„理

            VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
            var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
            var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
            var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
            var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
            var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
            var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
            var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
            var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
            var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

            string processName = "";
            var firstWorkTask = await workTaskAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
            if (firstWorkTask == null)
            {
                throw new UserFriendlyException($"找不到作业计划");
            }
            //物料参数列表
            var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
            if (firstWorkPlan == null)
            {
                throw new UserFriendlyException($"找不到作业计划");
            }
            if (firstWorkPlan.ProcessName == "装配工序")
            {
                processName = "装配";
            }
            else if (firstWorkPlan.ProcessName == "焊接工序")
            {
                processName = "焊接";
            }

            await CompleteHandleOutStoreFinish(_serviceProvider, processName, true);

            //根据工序名获取工序对象
            var workSection = await _workSectionManager.GetByNameAsync($"{processName}工序");
            var workStation = await _workStationManager.GetByNameAsync($"{processName}工位");
            //写入追溯报表
            var finishTime = DateTime.Now;
            TraceModel traceModel = new TraceModel()
            {
                SerialNumber = input.PipeSpecCode,
                WorkSectionId = workSection.Id,
                WorkSectionName = workSection.Name,
                WorkStationName = workStation.Name,

                FinishTime = finishTime,
                IsQualified = true,
                UnqualifiedReason = "",
                ProductModel = "",
                ProductName = "",

            };
            traceModel.Params = new List<TraceParamModel>();
            foreach (var item in workSection.ProcessParameters)
            {
                var value = "ssss";
                traceModel.Params.Add(new TraceParamModel()
                {
                    Key = item.Key,
                    Value = value.SafeString()
                });
            }

            firstWorkTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            await workTaskRepository.UpdateAsync(firstWorkTask);
@@ -1066,6 +1071,12 @@

            await traceProvider.CreateTraceAsync(traceModel);

          

            #endregion

            await uow.CompleteAsync();

            var response = new MesOrderResponse
            {
                Code = "200",
@@ -1074,10 +1085,6 @@
                Time = DateTime.UtcNow
            };
            return response;

            #endregion

            await uow.CompleteAsync();
        }
        catch (Exception)
        {
@@ -1095,6 +1102,429 @@

    }

    #region æ³•å…°å†²ç 


    /// <summary>
    ///下发法兰冲码 å¼€å·¥
    /// </summary>
    /// <param name="input"></param>
    /// <param name="_serviceProvider"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task<MesOrderResponse> SendFlangeCode_StartProduction(SendFlangeCodeInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
    {
        if (string.IsNullOrEmpty(input.TaskCode.ToString()))
        {
            throw new UserFriendlyException("任务编码不能为空");
        }

        string processName = "法兰冲码";

        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
        var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
        var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();


        // æŸ¥æ‰¾æ•°æ®
        var workTask = await workTaskRepository.GetSingleByFilterAsync(x => x.Son_TaskCode == input.Son_TaskCode);
        if (workTask == null)
        {
            throw new UserFriendlyException($"没有找到子任务编号{input.Son_TaskCode}的任务数据");
        }
        if (workTask.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.未生产)
        {
            throw new UserFriendlyException($"子任务编号{input.Son_TaskCode}的任务状态不是'{Domain.Shared.Enums.WorkPlanStatusEnum.未生产.ToString()}'");
        }
        var workPlan = await workPlanRepository.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
        if (workPlan == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }


        // éªŒè¯çŠ¶æ€
        if (workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.暂停中 && workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.未生产)
        {
            //暂时注释
            //throw new UserFriendlyException($"任务编码 '{input.TaskCode}' çš„录状态为 '{workPlan.WorkPlanStatus}'，不允许开工");
        }

        var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == workPlan.DataIdentifier);
        #region äº‹åŠ¡

        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);

        try
        {
            #region æ•°æ®å¤„理

            //1、更新作业计划表为 ç”Ÿäº§ä¸­
            //2、给PLC发工艺参数指令,并写入 plc中 äº§å“id
            //if (workPlan.ProcessName == "装配工序")
            //{
            //    workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
            //}
            //else if (workPlan.ProcessName == "焊接工序")
            //{
            //    workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            //}
            workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
            workTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;

            await workPlanRepository.UpdateAsync(workPlan);

            await workTaskRepository.UpdateAsync(workTask);

            Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
                        {
                            { $"{processName}_ProductID", workPlan.PipeSpecCode },
                            { $"{processName}管段编码", workPlan.PipeSpecCode },
                            { $"{processName}管段名称", workPlan.PipeSectionName },
                            { $"{processName}原料管批次", callMaterialOrder.MaterialBatch },
                            { $"{processName}原料管型号", callMaterialOrder.MaterialMode },
                            { $"{processName}原料管标识", callMaterialOrder.DataIdentifier },
                            { $"{processName}项目号", workPlan.ProjectNumber },
                            { $"{processName}船号", workPlan.ShipNumber },

                            //采集数据模拟写入
                            { $"{processName}压力", "10.0 MPa" },
                            { $"{processName}速度", "18mm/s"},

                            { $"{processName}内容", workTask.PipeAllowableStress},

                            { $"{processName}人", myCurrentUser.UserAccount},
                            { $"{processName}间隙","15mm"},
                            { $"{processName}位置", "10,23,24"},
                        };
            _variableService.WriteValueAsync(keyValuePairs);


            #endregion

            await uow.CompleteAsync();

            // è¿”回结果
            var response = new MesOrderResponse
            {
                Code = "200",
                Message = "处理成功",
                Time = DateTime.UtcNow
            };
            return response;
        }
        catch (Exception)
        {
            await uow.RollbackAsync();
            throw;
        }
        finally
        {

        }



        #endregion
    }


    /// <summary>
    /// ä¸‹å‘法兰冲码 å®Œå·¥
    /// </summary>
    /// <param name="_serviceProvider"></param>
    /// <param name="input"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    public async Task<MesOrderResponse> SendFlangeCode_CompleteAssemblyProcess(IServiceProvider _serviceProvider, CompleteAssemblyProcessInput input, MyCurrentUser myCurrentUser)
    {
        //1、记录分拣记录表
        //2、更新作业计划表的状态 =已分拣
        //3、写入 åˆ†æ‹£å˜é‡
        //4、写入追溯报表
        //5、物料组盘

        if (string.IsNullOrEmpty(input.PipeSpecCode))
        {
            throw new UserFriendlyException($"管段编码不能为空");
        }




        #region äº‹åŠ¡

        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);

        try
        {
            #region æ•°æ®å¤„理

            VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
            var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
            var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
            var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
            var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
            var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
            var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
            var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
            var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
            var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

            string processName = "法兰冲码";
            var firstWorkTask = await workTaskAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == (input.ProcessName));
            if (firstWorkTask == null)
            {
                throw new UserFriendlyException($"找不到作业计划");
            }
            //物料参数列表
            var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == "装配工序");
            if (firstWorkPlan == null)
            {
                throw new UserFriendlyException($"找不到作业计划");
            }

            await CompleteHandleOutStoreFinish(_serviceProvider, processName, true);

            //根据工序名获取工序对象
            var workSection = await _workSectionManager.GetByNameAsync($"{processName}工序");
            var workStation = await _workStationManager.GetByNameAsync($"{processName}工位");
            //写入追溯报表
            var finishTime = DateTime.Now;
            TraceModel traceModel = new TraceModel()
            {
                SerialNumber = input.PipeSpecCode,
                WorkSectionId = workSection.Id,
                WorkSectionName = workSection.Name,
                WorkStationName = workStation.Name,

                FinishTime = finishTime,
                IsQualified = true,
                UnqualifiedReason = "",
                ProductModel = "",
                ProductName = "",

            };
            traceModel.Params = new List<TraceParamModel>();
            foreach (var item in workSection.ProcessParameters)
            {
                var value = "ssss";
                traceModel.Params.Add(new TraceParamModel()
                {
                    Key = item.Key,
                    Value = value.SafeString()
                });
            }

            firstWorkTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            await workTaskRepository.UpdateAsync(firstWorkTask);

            //这个地方不改数据
            //firstWorkPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            //await workPlanRepository.UpdateAsync(firstWorkPlan);

            var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == firstWorkPlan.DataIdentifier);

            var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
            var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
            var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
            var rawPipe_ProjectNumber = await materialProvider.FindByNameAsync("项目号");
            var rawPipe_ShipNumber = await materialProvider.FindByNameAsync("船号");
            List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
            foreach (var item in workSection.MaterialParameters)
            {
                if (item.Name == "原料管型号")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_MaterialMode.MaterialId,
                        MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
                        Value = firstWorkPlan.MaterialMode

                    });
                }
                if (item.Name == "原料管标识")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_DataIdentifier.MaterialId,
                        MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
                        Value = firstWorkPlan.DataIdentifier,

                    });
                }
                if (item.Name == "原料管批次")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_Batch.MaterialId,
                        MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
                        Value = callMaterialOrder.MaterialBatch,//批次暂时写死

                    });
                }
                if (item.Name == "项目号")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_ProjectNumber.MaterialId,
                        MaterialDetailId = rawPipe_ProjectNumber.MaterialDetails.First().Id,
                        Value = firstWorkPlan.ProjectNumber,

                    });
                }
                if (item.Name == "船号")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_ShipNumber.MaterialId,
                        MaterialDetailId = rawPipe_ShipNumber.MaterialDetails.First().Id,
                        Value = firstWorkPlan.ShipNumber,

                    });
                }
            };

            //配置过程参数(采集参数、配方参数)
            traceModel.Params = new List<TraceParamModel>();
            foreach (var item in workSection.ProcessParameters)
            {
                string _value = "";

                //采集参数
                if (item.Name == $"{processName}压力")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}压力");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}位置")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}位置");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}速度")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}速度");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }

                if (item.Name == $"{processName}间隙")
                {
                    _value = "15mm";
                }
                if (item.Name == $"{processName}人")
                {
                    _value = myCurrentUser.UserAccount;
                }
                //item.Key
                TraceParamModel traceParamModel = new TraceParamModel()
                {
                    Key = item.Key,
                    Value = _value
                };
                traceModel.Params.Add(traceParamModel);
            };
            foreach (var item in workSection.FormulaParameters)
            {
                string _value = "";

                //采集参数
                if (item.Name == $"{processName}压力")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}压力");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}位置")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}位置");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}速度")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}速度");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}内容")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}内容");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }

                if (item.Name == $"{processName}间隙")
                {
                    _value = "15mm";
                }
                if (item.Name == $"{processName}人")
                {
                    _value = myCurrentUser.UserAccount;
                }
                //item.Key
                TraceParamModel traceParamModel = new TraceParamModel()
                {
                    Key = item.Key,
                    Value = _value
                };
                traceModel.Params.Add(traceParamModel);
            };

            traceModel.MaterialParams = _MaterialParams;

            await traceProvider.CreateTraceAsync(traceModel);

         

            #endregion

            await uow.CompleteAsync();

            var response = new MesOrderResponse
            {
                Code = "200",
                Data = "",
                Message = "处理成功",
                Time = DateTime.UtcNow
            };
            return response;
        }
        catch (Exception)
        {
            await uow.RollbackAsync();
            throw;
        }
        finally
        {

        }



        #endregion

    }

    #endregion


    /// <summary>
    /// å…¬å…±å¤„理 å“åº”出站完成信号

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems/CMSPluginEntry.cs

@@ -50,6 +50,7 @@
        context.Services.AddSingleton<IProjectService, PipeLineLemsProjectService>();
        context.Services.AddScoped<IMesAppService, MesAppService>();
        context.Services.AddScoped<IWorkPlanAppService, WorkPlanAppService>();
        context.Services.AddScoped<IWorkTaskAppService, WorkTaskAppService>();
        //context.Services.AddScoped<ILMesOperateAppService, LMesOperateAppService>();
        //context.Services.AddScoped<IWmsTaskRepository, EfCoreWmsTaskRepository>();
        //context.Services.AddScoped<IWmsMaterialRepository, EfCoreWmsMaterialRepository>();

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems/Controller/WorkPlanPublicController.cs

@@ -113,6 +113,64 @@
        }

        /// <summary>
        /// ä¸‹å‘法兰冲码
        /// </summary>
        /// <param name="input">标识符.</param>
        /// <returns></returns>
        [Authorize]
        [HttpPost]
        [Route("SendFlangeCode")]
        public virtual async Task<MesOrderResponse> SendFlangeCode([FromBody] SendFlangeCodeInput input)
        {
            try
            {
                MyCurrentUser myCurrentUser = new MyCurrentUser()
                {
                    UserAccount = _currentUser.UserAccount,
                    UserId = _currentUser.UserId
                };
                return await sharedService.SendFlangeCode_StartProduction(input, _serviceProvider, myCurrentUser);
            }
            catch (Exception ex)
            {
                return new MesOrderResponse()
                {
                    Code = "400",
                    Message = ex.Message
                };
            }
        }

        /// <summary>
        /// æ³•å…°å†²ç å®Œå·¥
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [Authorize]
        [HttpPost]
        [Route("SendFlangeCode_FinishProduction")]
        public virtual async Task<MesOrderResponse> SendFlangeCode_FinishProduction([FromBody] CompleteAssemblyProcessInput input)
        {
            try
            {
                MyCurrentUser myCurrentUser = new MyCurrentUser()
                {
                    UserAccount = _currentUser.UserAccount,
                    UserId = _currentUser.UserId
                };
                return await sharedService.SendFlangeCode_CompleteAssemblyProcess(_serviceProvider, input, myCurrentUser);
            }
            catch (Exception ex)
            {
                return new MesOrderResponse()
                {
                    Code = "400",
                    Message = ex.Message
                };
            }
        }

        /// <summary>
        /// å¼€å·¥
        /// </summary>
        /// <param name="input"></param>

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems/ProjectService/PipeLineLemsProjectService.cs

@@ -37,7 +37,6 @@
        private readonly ILogger<PipeLineLemsProjectService> _logger;
        private readonly IVariableDataCache _variableDataCache;


        /// <summary>
        /// å˜é‡æœåŠ¡
        /// </summary>
@@ -96,6 +95,7 @@

                { "装配完工信号", "装配完工信号(描述)" },
                { "焊接完工信号", "焊接完工信号(描述)" },
                { "法兰冲码完工信号", "法兰冲码完工信号(描述)" },
            };

            // åˆ›å»ºé€šé“监听
@@ -296,6 +296,24 @@
                        _ = Task.Run(async () =>
                        {
                            await HanlderFor完工信号WhenFalseAsync("焊接");
                        });
                    }
                }

                if (changed.Name == "法兰冲码完工信号")
                {
                    if (changed.New?.Value.SafeString().ToBool() == true)
                    {
                        _ = Task.Run(async () =>
                        {
                            await HanlderFor法兰冲码完工信号Async();
                        });
                    }
                    else
                    {
                        _ = Task.Run(async () =>
                        {
                            await HanlderFor完工信号WhenFalseAsync("法兰冲码");
                        });
                    }
                }
@@ -892,12 +910,12 @@
                    {
                        UserAccount = userName.Content.Value.SafeString().ToString()
                    };
                    sharedService.CompleteAssemblyProcess(_serviceProvider, new Application.Contracts.Dtos.WorkPlan.CompleteAssemblyProcessInput() { PipeSpecCode = myPipeSpecCode, ProcessName = "装配工序" }, myCurrentUser);
                    await sharedService.CompleteAssemblyProcess(_serviceProvider, new Application.Contracts.Dtos.WorkPlan.CompleteAssemblyProcessInput() { PipeSpecCode = myPipeSpecCode, ProcessName = "装配工序" }, myCurrentUser);

                }
                catch (Exception)
                catch (Exception ex)
                {

                    _logger.LogException(ex, LogLevel.Error);
                }
            }
        }
@@ -934,12 +952,53 @@
                    {
                        UserAccount = userName.Content.Value.SafeString().ToString()
                    };
                    sharedService.CompleteAssemblyProcess(_serviceProvider, new Application.Contracts.Dtos.WorkPlan.CompleteAssemblyProcessInput() { PipeSpecCode = myPipeSpecCode, ProcessName = "焊接工序" }, myCurrentUser);
                    await sharedService.CompleteAssemblyProcess(_serviceProvider, new Application.Contracts.Dtos.WorkPlan.CompleteAssemblyProcessInput() { PipeSpecCode = myPipeSpecCode, ProcessName = "焊接工序" }, myCurrentUser);

                }
                catch (Exception)
                catch (Exception ex)
                {
                    _logger.LogException(ex, LogLevel.Error);
                }
            }
        }

        /// <summary>
        /// æ³•å…°å†²ç å®Œå·¥ä¿¡å·=true时
        /// </summary>
        /// <returns></returns>
        private async Task HanlderFor法兰冲码完工信号Async()
        {

            var txt = "法兰冲码";
            var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
            var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
            var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

            var pipeSpecCode = await _variableService.ReadValueAsync($"{txt}管段编码");

            if (string.IsNullOrEmpty(pipeSpecCode?.Content?.Value.SafeString().ToString()))
            {

            }
            else
            {
                var myPipeSpecCode = pipeSpecCode.Content.Value.SafeString().ToString();
                CallMaterialOrder callMaterialOrder = null;
                try
                {
                    var sharedService = _serviceProvider.GetRequiredService<SharedService>();
                    var userName = await _variableService.ReadValueAsync($"{txt}人");
                    MyCurrentUser myCurrentUser = new MyCurrentUser()
                    {
                        UserAccount = userName.Content.Value.SafeString().ToString()
                    };
                    await sharedService.SendFlangeCode_CompleteAssemblyProcess(_serviceProvider, new Application.Contracts.Dtos.WorkPlan.CompleteAssemblyProcessInput()
                    { PipeSpecCode = myPipeSpecCode, ProcessName = $"{txt}工序" }, myCurrentUser);

                }
                catch (Exception ex)
                {
                    _logger.LogException(ex, LogLevel.Error);
                }
            }
        }