222

schangxiang@126.com

2025-05-11 61361fabdb34b5aab1b7b349be827681b7c56c53

222

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems/ProjectService/PipeLineLemsProjectService - ¸´ÖÆ.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,341 @@
//using CMS.Extensions.Variable;
//using CMS.Plugin.FlowManagement.Abstractions.FlowBusiness;
//using CMS.Plugin.PipeLineLems.Apis;
//using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.MyTestEntityNames;
//using CMS.Plugin.PipeLineLems.Domain.MyTestEntityNames;
//using CMS.Plugin.PipeLineLems.Jobs;
//using CMS.Plugin.ProcessManagement.Abstractions;
//using CMS.Plugin.TraceManagement.Abstractions.Models.Traces;
//using CMS.Plugin.TraceManagement.Abstractions;
//using CMS.Project;
//using CMS.Project.Abstractions;
//using CMS.Unit.RuntimeValue.Abstractions;
//using KissUtil.Extensions;
//using Microsoft.Extensions.DependencyInjection;
//using Microsoft.Extensions.Logging;
//using System;
//using Volo.Abp.BackgroundJobs;
//using Volo.Abp.Uow;

//namespace CMS.Plugin.PipeLineLems.ProjectService
//{
//    /// <summary>
//    /// å·¥ç¨‹æœåŠ¡ï¼Œå’Œå·¥ç¨‹å…³è”的后台服务，当<see cref="IProjectServiceRunner"/>以当前Key调用时会被执行
//    /// </summary>
//    public class PipeLineLemsProjectService : BaseProjectService
//    {
//        private IServiceProvider _serviceProvider;
//        private readonly ILogger<PipeLineLemsProjectService> _logger;
//        private readonly IVariableDataCache _variableDataCache;

//        /// <summary>
//        /// å˜é‡æœåŠ¡
//        /// </summary>
//        private readonly VariableService _variableService;
//        private FlowVariableChannelListener _channelListener;
//        private Dictionary<string, string> _monitorVariableNames;

//        /// <summary>
//        /// æœåŠ¡çš„Key，唯一，供<see cref="IProjectServiceRunner"/>使用
//        /// </summary>
//        public override string Key => "PipeLineLems";

//        /// <summary>
//        /// æœåŠ¡æè¿°ï¼Œæ˜¾ç¤ºåœ¨æœåŠ¡åˆ—表UI上的名称
//        /// </summary>
//        public override string Description => "PipeLineLems服务";

//        /// <summary>
//        /// å¯ç”¨æŽˆæƒ
//        /// </summary>
//        public override bool AuthRequired => true;

//        /// <summary>
//        /// Initializes a new instance of the <see cref="PipeLineLemsProjectService"/> class.
//        /// </summary>
//        /// <param name="logger">The logger.</param>
//        /// <param name="variableDataCache">The variable data cache.</param>
//        public PipeLineLemsProjectService(
//            VariableService variableService,
//            IServiceProvider serviceProvider, ILogger<PipeLineLemsProjectService> logger, IVariableDataCache variableDataCache)
//        {
//            _serviceProvider = serviceProvider;
//            _logger = logger;
//            _variableDataCache = variableDataCache;
//            _variableService = variableService;
//        }

//        /// <summary>
//        /// å¼€å¯æœåŠ¡
//        /// </summary>
//        /// <param name="serviceProvider">具有工程上下文的实例</param>
//        public override async Task StartAsync(IServiceProvider serviceProvider)
//        {
//            if (State == ProjectServiceState.Started)
//            {
//                return;
//            }

//            // ç›‘听变量
//            _monitorVariableNames = new Dictionary<string, string>
//            {
//                { "打码进站信号", "打码进站信号(描述)" },
//                { "切割进站信号", "切割进站信号(描述)" },
//            };

//            // åˆ›å»ºé€šé“监听
//            _channelListener?.Token?.Dispose();
//            _channelListener = new FlowVariableChannelListener(_logger, _variableDataCache);
//            _channelListener.CreateChannel(Key, waitListener: false, timeout: TimeSpan.FromSeconds(30), variableFilter: _monitorVariableNames.Keys.ToHashSet());
//            _channelListener.TagChanged += OnTagValueChanged;

//            await base.StartAsync(serviceProvider);
//        }

//        /// <summary>
//        /// åœæ­¢æœåŠ¡
//        /// </summary>
//        /// <param name="serviceProvider">具有工程上下文的实例</param>
//        public override async Task StopAsync(IServiceProvider serviceProvider)
//        {
//            if (_channelListener != null)
//            {
//                // é‡Šæ”¾ç›‘听
//                _channelListener.TagChanged -= OnTagValueChanged;
//                _channelListener.Token.Dispose();
//                _channelListener = null;
//            }

//            // ä½¿ç”¨åŽå°ä½œä¸šå¼‚步处理
//            //await _serviceProvider.GetRequiredService<IBackgroundJobManager>().EnqueueAsync(new PipeLineLemsArgs
//            //{
//            //    Subject = "PipeLineLems_Subject",
//            //    Body = "PipeLineLems_Body",
//            //});


//            await base.StopAsync(serviceProvider);
//        }

//        /// <summary>
//        /// Called when [tag value changed].
//        /// </summary>
//        /// <param name="sender">The sender.</param>
//        /// <param name="e">The <see cref="TagChangedEventArgs"/> instance containing the event data.</param>
//        private async void OnTagValueChanged(object sender, TagChangedEventArgs e)
//        {
//            var changeds = e.Changeds.Where(x => _monitorVariableNames != null && _monitorVariableNames.ContainsKey(x.Name));
//            if (!changeds.Any())
//            {
//                return;
//            }

//            foreach (var changed in changeds)
//            {
//                var oldValue = changed.Old?.Value;
//                var newValue = changed.New?.Value;
//                var traceId = e.TraceId;

//                _logger.LogInformation($"{changed.Name} å˜é‡å€¼å‘生变化，旧值{oldValue}=新值{newValue}，TraceId={traceId}");

//                if (changed.Name == "打码进站信号" && changed.New?.Value.SafeString().ToBool() == true)
//                {

//                    // TODO: å¤„理变量值变化
//                    // Tips：https://cms-docs.shengyc.com/cms/api/%E5%90%8E%E7%AB%AF#3-%E5%8F%98%E9%87%8F%E6%A8%A1%E5%9D%97
//                    /* è¯´æ˜Žï¼šé€šè¿‡è®¢é˜… IVariableDataCache.TagChanged äº‹ä»¶ï¼Œæ‚¨å¯ä»¥å®žæ—¶ç›‘控变量的变化。此事件会传递所有变量至事件处理函数，因此，业务层需在函数中筛选关注的变量。
//                        æ³¨æ„äº‹é¡¹ï¼š
//                        ï¼ˆ1）性能影响： å‘布事件时，事件的发送者将阻塞流程。因此，强烈建议避免在事件处理函数中执行 I/ O æ“ä½œã€HTTP æŽ¥å£è®¿é—®æˆ–其他耗时操作，以防止对系统性能产生严重影响，导致整个系统响应延迟。
//                        ï¼ˆ2）高频率触发： ç”±äºŽäº‹ä»¶è®¢é˜…了全量变量，触发频率可能非常高。
//                        ï¼ˆ3）异步处理： é‰´äºŽäº‹ä»¶è§¦å‘频率很高，建议业务层在筛选关注变量后，使用 Task å¯åŠ¨æ–°çº¿ç¨‹å¤„理业务逻辑，以避免阻塞核心的变量监听功能，实现业务层与平台基座的解耦。
//                        ï¼ˆ4）并发管理： å¦‚果业务层并发量大，必须优化代码设计和实施，以减少在高并发情况下的系统资源消耗，防止系统性能问题。
//                        ï¼ˆ5）代码安全： å®‰è£…并使用 CMS.CodeAnalysis åˆ†æžå™¨æ¥åˆ†æž IVariableDataCache.TagChanged çš„使用情况。该工具能在使用不当时提供编译错误，帮助您提高代码质量。*/

//                    _ = Task.Run(async () =>
//                    {
//                        await HanlderForPringBarCodeAsync();
//                        // ä¾‹1：同步处理
//                        //await ProcessAsync();

//                        // ä¾‹2：调用外部API
//                        //await ExecuteExternalApiAsync();
//                    });
//                }

//                if (changed.Name == "切割进站信号" && changed.New?.Value.SafeString().ToBool() == true)
//                {

//                    // TODO: å¤„理变量值变化
//                    // Tips：https://cms-docs.shengyc.com/cms/api/%E5%90%8E%E7%AB%AF#3-%E5%8F%98%E9%87%8F%E6%A8%A1%E5%9D%97
//                    /* è¯´æ˜Žï¼šé€šè¿‡è®¢é˜… IVariableDataCache.TagChanged äº‹ä»¶ï¼Œæ‚¨å¯ä»¥å®žæ—¶ç›‘控变量的变化。此事件会传递所有变量至事件处理函数，因此，业务层需在函数中筛选关注的变量。
//                        æ³¨æ„äº‹é¡¹ï¼š
//                        ï¼ˆ1）性能影响： å‘布事件时，事件的发送者将阻塞流程。因此，强烈建议避免在事件处理函数中执行 I/ O æ“ä½œã€HTTP æŽ¥å£è®¿é—®æˆ–其他耗时操作，以防止对系统性能产生严重影响，导致整个系统响应延迟。
//                        ï¼ˆ2）高频率触发： ç”±äºŽäº‹ä»¶è®¢é˜…了全量变量，触发频率可能非常高。
//                        ï¼ˆ3）异步处理： é‰´äºŽäº‹ä»¶è§¦å‘频率很高，建议业务层在筛选关注变量后，使用 Task å¯åŠ¨æ–°çº¿ç¨‹å¤„理业务逻辑，以避免阻塞核心的变量监听功能，实现业务层与平台基座的解耦。
//                        ï¼ˆ4）并发管理： å¦‚果业务层并发量大，必须优化代码设计和实施，以减少在高并发情况下的系统资源消耗，防止系统性能问题。
//                        ï¼ˆ5）代码安全： å®‰è£…并使用 CMS.CodeAnalysis åˆ†æžå™¨æ¥åˆ†æž IVariableDataCache.TagChanged çš„使用情况。该工具能在使用不当时提供编译错误，帮助您提高代码质量。*/

//                    _ = Task.Run(async () =>
//                    {
//                        await HanlderForCutAsync();
//                        // ä¾‹1：同步处理
//                        //await ProcessAsync();

//                        // ä¾‹2：调用外部API
//                        //await ExecuteExternalApiAsync();
//                    });
//                }
//            }
//        }

//        /// <summary>
//        /// Processes the asynchronous.
//        /// </summary>
//        private async Task ProcessAsync()
//        {
//            using var scope = _serviceProvider.CreateScope();
//            var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
//            using var uow = unitOfWorkManager.Begin(requiresNew: true);
//            var mytestentitynameRepository = scope.ServiceProvider.GetRequiredService<IMyTestEntityNameRepository>();
//            var count = await mytestentitynameRepository.GetCountAsync();

//            // å¦‚果有更新数据库操作，需提交保存
//            // await uow.SaveChangesAsync();

//            _logger.LogInformation($"ProcessAsync，Count={count}");
//        }

//        /// <summary>
//        /// Executes the external API.
//        /// </summary>
//        private async Task ExecuteExternalApiAsync()
//        {
//            try
//            {
//                await _serviceProvider.GetRequiredService<IPipeLineLemsExternalApi>().CreateAsync(new MyTestEntityNameCreateDto
//                {
//                    Name = "MyTestEntityName_Name",
//                    Code = "MyTestEntityName_Code",
//                });
//            }
//            catch (Exception e)
//            {
//                _logger.LogException(e);
//            }
//        }

//        /// <summary>
//        /// æ‰“码
//        /// </summary>
//        /// <returns></returns>
//        private async Task HanlderForPringBarCodeAsync()
//        {

//            var plcTaskNo = await _variableService.ReadValueAsync("打码进站PLC任务号");

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

//            }
//            else
//            {
//                var myTaskNo = plcTaskNo.Content.Value.SafeString().ToString();
//                //TODO:暂时先写入 å†…部变量
//                Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
//                    {
//                        { "打码工件1", "11111111" },
//                        { "打码工件2", "22222222" },
//                        { "打码工件3", "33333333" }
//                    };
//                _variableService.WriteValueAsync(keyValuePairs);

//                //TODO:模拟采集参数
//                keyValuePairs = new Dictionary<string, object?>
//                    {
//                        { "打码速度", 100},
//                        { "打码质量", 2},
//                    };
//                var ret2 = _variableService.WriteValueAsync(keyValuePairs);

//                //TODO:暂时生成产品ID
//                //var productID = Guid.NewGuid().ToString();
//                var productID = DateTime.Now.ToString("yyyyMMddHHmmssfff");
//                keyValuePairs = new Dictionary<string, object?>
//                    {
//                        { "打码_ProductID", productID},
//                    };
//                var ret = _variableService.WriteValueAsync(keyValuePairs);
//            }
//        }


//        /// <summary>
//        /// åˆ‡å‰²
//        /// </summary>
//        /// <returns></returns>
//        private async Task HanlderForCutAsync()
//        {

//            var plcTaskNo = await _variableService.ReadValueAsync("切割进站PLC任务号");

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

//            }
//            else
//            {
//                var myTaskNo = plcTaskNo.Content.Value.SafeString().ToString();
//                //TODO:暂时先写入 å†…部变量
//                Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
//                    {
//                        { "切割1", "555555" },
//                        { "切割2", "66666" },
//                        { "切割3", "77777" }
//                    };
//                _variableService.WriteValueAsync(keyValuePairs);

//                //TODO:模拟采集参数
//                keyValuePairs = new Dictionary<string, object?>
//                    {
//                        { "切割速度", 99},
//                        { "切割质量", 1},
//                    };
//                var ret2 = _variableService.WriteValueAsync(keyValuePairs);

//                //TODO:暂时生成产品ID
//                //获取上一个工序的产品ID
//                //根据工序名获取工序对象
//                var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
//                var lastWorkSection = "打码工序";
//                var workSection = await _workSectionManager.GetByNameAsync(lastWorkSection);

//                //获取工单数据（从末工序查询3个产品）
//                //读取scms_productions表，根据当前时间查询最近3条记录
//                var traceManager = _serviceProvider.GetRequiredService<ITraceProvider>();
//                GetTracesRequest request = new GetTracesRequest()
//                {
//                    WorkSectionId = workSection.Id,
//                };
//                TraceModel traceModel = null;
//                var list = await traceManager.GetTracesAsync(request);
//                if (list?.Count > 0)
//                {
//                    //重新排序
//                    list = list.OrderByDescending(x => x.FinishTime).ToList();
//                    traceModel = list.First();
//                }
//                //var productID = Guid.NewGuid().ToString();
//                var productID = DateTime.Now.ToString("yyyyMMddHHmmssfff");
//                if (traceModel != null)
//                {
//                    productID = traceModel.SerialNumber;
//                }
//                keyValuePairs = new Dictionary<string, object?>
//                    {
//                        { "切割_ProductID", productID},
//                    };
//                var ret = _variableService.WriteValueAsync(keyValuePairs);
//            }
//        }
//    }
//}

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

@@ -19,6 +19,7 @@
using CMS.Plugin.PipeLineLems.Application.Contracts.Services;
using CMS.Plugin.PipeLineLems.Domain.WorkPlan;
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrder;
using System.Collections.Generic;

namespace CMS.Plugin.PipeLineLems.ProjectService
{
@@ -250,6 +251,16 @@
            }
            else
            {

                //TODO:暂时生成产品ID
                var productID = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                //var productID = new_workPlanList.Last().PipeSpecCode;
                Dictionary<string, object?> keyValuePairs_productID = new Dictionary<string, object?>
                    {
                        { "打码_ProductID", productID},
                    };
                var ret = _variableService.WriteValueAsync(keyValuePairs_productID);

                var myTaskNo = plcTaskNo.Content.Value.SafeString().ToString();
                CallMaterialOrder callMaterialOrder = null;
                try
@@ -309,14 +320,7 @@
                    };
                    var ret2 = _variableService.WriteValueAsync(keyValuePairs);

                    //TODO:暂时生成产品ID
                    var productID = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                    //var productID = new_workPlanList.Last().PipeSpecCode;
                    keyValuePairs = new Dictionary<string, object?>
                    {
                        { "打码_ProductID", productID},
                    };
                    var ret = _variableService.WriteValueAsync(keyValuePairs);



                    uow.CompleteAsync();