SOMS/src/YunDa.Application/YunDa.SOMS.Application/DataMonitoring/SecondaryCircuitInspection/SecondaryCircuitEventDrivenConfigAppService.cs

using Abp.Auditing;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.EntityFrameworkCore.Repositories;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ToolLibrary.LogHelper;
using YunDa.SOMS.Application.Core;
using YunDa.SOMS.Application.Core.Session;
using YunDa.SOMS.Application.Core.SwaggerHelper;
using YunDa.SOMS.DataTransferObject;
using YunDa.SOMS.DataTransferObject.Account;
using YunDa.SOMS.DataTransferObject.DataMonitoring.SecondaryCircuitInspection;
using YunDa.SOMS.DataTransferObject.DataMonitoring.SecondaryCircuitInspection.Configurations;
using YunDa.SOMS.DataTransferObject.DataMonitoring.TelemeteringConfigurationDto;
using YunDa.SOMS.DataTransferObject.DataMonitoring.TelesignalisationConfigurationDto;
using YunDa.SOMS.DataTransferObject.GeneralInformation.EquipmentLiveDataDto;
using YunDa.SOMS.Entities.DataMonitoring.SecondaryCircuitInspection;
using YunDa.SOMS.Redis.Repositories;

namespace YunDa.SOMS.Application.DataMonitoring.SecondaryCircuitInspection
{
    /// <summary>
    /// 二次回路事件驱动配置应用服务实现
    /// </summary>
    [Description("二次回路事件驱动配置管理服务")]
    public class SecondaryCircuitEventDrivenConfigAppService : SOMSAppServiceBase, ISecondaryCircuitEventDrivenConfigAppService
    {
        private readonly IRepository<SecondaryCircuitEventDrivenConfig, Guid> _eventDrivenConfigRepository;
        private readonly IRepository<SecondaryCircuitInspectionItem, Guid> _inspectionItemRepository;
        private readonly IRepository<SecondaryCircuitInspectionEventItem, Guid> _inspectionEventItemRepository;
        private readonly IRepository<SecondaryCircuitInspectionTelemetryConfig, Guid> _telemetryConfigRepository;
        private readonly IRepository<SecondaryCircuitInspectionTelesignalConfig, Guid> _telesignalConfigRepository;
        private readonly IRedisRepository<TelemeteringModel, string> _telemeteringRedisRepository;
        private readonly IRedisRepository<TelesignalisationModel, string> _telesignalisationRedisRepository;
        private LoginUserOutput _currentUser = null;
        private IUnitOfWorkManager _unitOfWorkManager = null;


        public SecondaryCircuitEventDrivenConfigAppService(
            IRepository<SecondaryCircuitEventDrivenConfig, Guid> eventDrivenConfigRepository,
            IRepository<SecondaryCircuitInspectionItem, Guid> inspectionItemRepository,
            IRepository<SecondaryCircuitInspectionEventItem, Guid> inspectionEventItemRepository,
            IRepository<SecondaryCircuitInspectionTelemetryConfig, Guid> telemetryConfigRepository,
            IRepository<SecondaryCircuitInspectionTelesignalConfig, Guid> telesignalConfigRepository,
            IRedisRepository<TelemeteringModel, string> telemeteringRedisRepository,
            IRedisRepository<TelesignalisationModel, string> telesignalisationRedisRepository,
            IUnitOfWorkManager unitOfWorkManager,
            ISessionAppService sessionAppService) : base(sessionAppService)
        {
            _unitOfWorkManager = unitOfWorkManager;
            _eventDrivenConfigRepository = eventDrivenConfigRepository;
            _inspectionItemRepository = inspectionItemRepository;
            _inspectionEventItemRepository = inspectionEventItemRepository;
            _telemetryConfigRepository = telemetryConfigRepository;
            _telesignalConfigRepository = telesignalConfigRepository;
            _telemeteringRedisRepository = telemeteringRedisRepository;
            _telesignalisationRedisRepository = telesignalisationRedisRepository;
        }

        #region 增/改

        /// <summary>
        /// 创建或更新事件驱动配置
        /// </summary>
        [HttpPost, Audited, Description("创建或更新事件驱动配置")]
        [ShowApi]
        [AllowAnonymous]
        public async Task<RequestResult<SecondaryCircuitEventDrivenConfigOutput>> CreateOrUpdateAsync(
            EditSecondaryCircuitEventDrivenConfigInput input,
            CancellationToken cancellationToken = default)
        {
            if (input == null) return null;
            if (_currentUser == null)
                _currentUser = base.GetCurrentUser();
            
            return input.Id.HasValue ? 
                await this.UpdateAsync(input, cancellationToken).ConfigureAwait(false) : 
                await this.CreateAsync(input, cancellationToken).ConfigureAwait(false);
        }

        /// <summary>
        /// 创建事件驱动配置
        /// </summary>
        private async Task<RequestResult<SecondaryCircuitEventDrivenConfigOutput>> CreateAsync(
            EditSecondaryCircuitEventDrivenConfigInput input,
            CancellationToken cancellationToken = default)

        {
            var rst = new RequestResult<SecondaryCircuitEventDrivenConfigOutput>();
            try
            {
               

               
                // 验证配置名称是否重复（排除当前记录）
                var nameExists = await _eventDrivenConfigRepository.GetAll()
                    .AnyAsync(x => x.Name == input.Name && x.Id != input.Id, cancellationToken);
                if (nameExists)
                {
                    rst.Message = "已存在相同名称的事件驱动配置";
                    return rst;
                }
                input.CreationTime = DateTime.Now;
                input.CreatorUserId = _currentUser.Id;

                SecondaryCircuitEventDrivenConfig entity = ObjectMapper.Map<SecondaryCircuitEventDrivenConfig>(input);
                using var uow = _unitOfWorkManager.Begin();

                entity = await _eventDrivenConfigRepository.InsertAsync(entity).ConfigureAwait(false);
                uow.Complete();

                // 创建巡检项关联
                if (input.SecondaryCircuitInspectionEventItems != null && input.SecondaryCircuitInspectionEventItems.Count > 0)
                {
                    var secondaryCircuitInspectionEventItems = _inspectionItemRepository.GetAll()
                        .Where(t => input.SecondaryCircuitInspectionEventItems.Contains(t.Id))
                        .Select(t => t.Id);
                    foreach (var item in secondaryCircuitInspectionEventItems)
                    {
                        var secondaryCircuitInspectionEventItem = new SecondaryCircuitInspectionEventItem(entity.Id, item);
                        _inspectionEventItemRepository.Insert(secondaryCircuitInspectionEventItem);
                    }
                }

                // 创建遥测配置关联
                if (input.TelemetryConfigs != null && input.TelemetryConfigs.Count > 0)
                {
                    foreach (var telemetryConfigId in input.TelemetryConfigs)
                    {
                        
                            var telemetryConfig = new SecondaryCircuitInspectionTelemetryConfig
                            {
                                SecondaryCircuitEventDrivenConfigId = entity.Id,
                                TelemetryConfigurationId = telemetryConfigId,
                                IsActive = true
                            };
                            await _telemetryConfigRepository.InsertAsync(telemetryConfig).ConfigureAwait(false);
                       
                    }
                }

                // 创建遥信配置关联
                if (input.TelesignalConfigs != null && input.TelesignalConfigs.Count > 0)
                {

                    foreach (var telesignalConfigId in input.TelesignalConfigs)
                    {
                        
                            var telesignalConfig = new SecondaryCircuitInspectionTelesignalConfig
                            {
                                SecondaryCircuitEventDrivenConfigId = entity.Id,
                                TelesignalConfigurationId = telesignalConfigId,
                                IsActive = true
                            };
                            await _telesignalConfigRepository.InsertAsync(telesignalConfig).ConfigureAwait(false);
                       
                    }
                }

                rst.ResultData = ObjectMapper.Map<SecondaryCircuitEventDrivenConfigOutput>(entity);
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.ToString();
                Log4Helper.Error(this.GetType(), "创建事件驱动配置", ex);
            }
            return rst;
        }

        /// <summary>
        /// 更新事件驱动配置
        /// </summary>
        private async Task<RequestResult<SecondaryCircuitEventDrivenConfigOutput>> UpdateAsync(
            EditSecondaryCircuitEventDrivenConfigInput input,
            CancellationToken cancellationToken = default)
        {
            var rst = new RequestResult<SecondaryCircuitEventDrivenConfigOutput>();
            try
            {
                var entity = await _eventDrivenConfigRepository.FirstOrDefaultAsync(u => u.Id == input.Id).ConfigureAwait(false);
                if (entity == null)
                {
                    rst.Message = "事件驱动配置不存在";
                    return rst;
                }


                input.CreationTime = entity.CreationTime;
                input.CreatorUserId = entity.CreatorUserId.Value;
                input.LastModificationTime = DateTime.Now;
                input.LastModifierUserId = _currentUser.Id;

                if (!string.IsNullOrEmpty(input.Name))
                {
                    entity.Name = input.Name;
                }
                if (!string.IsNullOrEmpty(input.TriggerExpression))
                {
                    entity.TriggerExpression = input.TriggerExpression;
                }
                if (input.DelayTriggerSeconds.HasValue)
                {
                    entity.DelayTriggerSeconds = input.DelayTriggerSeconds.Value;
                }
                if (input.MandatoryWaitSeconds.HasValue)
                {
                    entity.MandatoryWaitSeconds = input.MandatoryWaitSeconds.Value;
                }
                if (input.TimeWindowSeconds.HasValue)
                {
                    entity.TimeWindowSeconds = input.TimeWindowSeconds.Value;
                }
                await _eventDrivenConfigRepository.UpdateAsync(entity);
               
                // 重新插入（仅当有数据时）
                if (input.SecondaryCircuitInspectionEventItems != null && input.SecondaryCircuitInspectionEventItems.Count > 0)
                {
                    // 更新巡检项关联（删除后重新插入）
                    // 删除现有关联
                    await _inspectionEventItemRepository.BatchDeleteAsync(t => t.InpectionEventDrivenId == entity.Id);

                    var secondaryCircuitInspectionEventItems = _inspectionItemRepository.GetAll()
                        .Where(t => input.SecondaryCircuitInspectionEventItems.Contains(t.Id))
                        .Select(t => t.Id);
                    foreach (var item in secondaryCircuitInspectionEventItems)
                    {
                        var secondaryCircuitInspectionEventItem = new SecondaryCircuitInspectionEventItem(entity.Id, item);
                        _inspectionEventItemRepository.Insert(secondaryCircuitInspectionEventItem);
                    }
                }

               
                // 重新插入遥测配置关联
                if (input.TelemetryConfigs != null && input.TelemetryConfigs.Count > 0)
                {
                    // 更新遥测配置关联（删除后重新插入）
                    // 删除现有遥测配置关联
                    await _telemetryConfigRepository.BatchDeleteAsync(t => t.SecondaryCircuitEventDrivenConfigId == entity.Id);

                    foreach (var telemetryConfigId in input.TelemetryConfigs)
                    {
                        var telemetryConfig = new SecondaryCircuitInspectionTelemetryConfig
                        {
                            SecondaryCircuitEventDrivenConfigId = entity.Id,
                            TelemetryConfigurationId = telemetryConfigId,
                            IsActive = true
                        };
                        await _telemetryConfigRepository.InsertAsync(telemetryConfig).ConfigureAwait(false);
                    }
                }

               
                // 重新插入遥信配置关联
                if (input.TelesignalConfigs != null && input.TelesignalConfigs.Count > 0)
                {
                    // 更新遥信配置关联（删除后重新插入）
                    // 删除现有遥信配置关联
                    await _telesignalConfigRepository.BatchDeleteAsync(t => t.SecondaryCircuitEventDrivenConfigId == entity.Id);

                    foreach (var telesignalConfigId in input.TelesignalConfigs)
                    {
                        var telesignalConfig = new SecondaryCircuitInspectionTelesignalConfig
                        {
                            SecondaryCircuitEventDrivenConfigId = entity.Id,
                            TelesignalConfigurationId = telesignalConfigId,
                            IsActive = true
                        };
                        await _telesignalConfigRepository.InsertAsync(telesignalConfig).ConfigureAwait(false);
                    }
                }

                rst.ResultData = ObjectMapper.Map<SecondaryCircuitEventDrivenConfigOutput>(entity);
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.ToString();
                Log4Helper.Error(this.GetType(), "更新事件驱动配置", ex);
            }
            return rst;
        }



        #endregion

        #region 查

         /// <summary>
         /// 查询所有事件驱动配置（不分页）
         /// </summary>
        [HttpPost, Description("查询所有事件驱动配置（不分页）")]
        [ShowApi]
        [AllowAnonymous]
        public RequestResult<List<SecondaryCircuitEventDrivenConfigOutput>> FindDatasNoPageList(
            SecondaryCircuitEventDrivenConfigSearchInput searchCondition)
        {
            var rst = new RequestResult<List<SecondaryCircuitEventDrivenConfigOutput>>();
            try
            {
                var query = _eventDrivenConfigRepository.GetAll()
                       .Include(x => x.SecondaryCircuitInspectionEventItems)
                        .ThenInclude(t => t.InspectionItem)
                    .Include(x => x.TelemetryConfigs)
                    .ThenInclude(t => t.TelemeteringConfiguration)
                    .ThenInclude(t => t.EquipmentInfo)
                    .Include(x => x.TelesignalConfigs)
                        .ThenInclude(t => t.TelesignalisationConfiguration)
                    .ThenInclude(t => t.EquipmentInfo)

                    .Where(x => x.IsActive);

                // 应用搜索条件
                if (searchCondition != null)
                {
                    if (!string.IsNullOrWhiteSpace(searchCondition.Name))
                    {
                        query = query.Where(x => x.Name.Contains(searchCondition.Name) ||
                                                x.Remark.Contains(searchCondition.Name));
                    }

                    if (searchCondition.Priority.HasValue)
                    {
                        query = query.Where(x => x.Priority == searchCondition.Priority.Value);
                    }
                }

                var entities = query.OrderBy(x => x.SortOrder).ThenBy(x => x.Name).ToList();

                // 映射到输出DTO
                var outputList = new List<SecondaryCircuitEventDrivenConfigOutput>();
                foreach (var entity in entities)
                {
                    var output = ObjectMapper.Map<SecondaryCircuitEventDrivenConfigOutput>(entity);
                    output.SecondaryCircuitInspectionEventItems = ObjectMapper.Map<List<SecondaryCircuitInspectionItemOutput>>(entity.SecondaryCircuitInspectionEventItems.Select(t => t.InspectionItem));
                    // 映射遥测配置关联
                    if (entity.TelemetryConfigs != null && entity.TelemetryConfigs.Any())
                    {
                        output.TelemetryConfigs = entity.TelemetryConfigs.Select(tc => new SecondaryCircuitInspectionTelemetryConfigOutput
                        {
                            Id = tc.Id,
                            SecondaryCircuitInspectionItemId = tc.SecondaryCircuitInspectionItemId,
                            TelemetryConfigurationId = tc.TelemetryConfigurationId ?? Guid.Empty,
                            TelemetryConfigurationName = tc.TelemeteringConfiguration?.Name,
                            EquipmentInfoId = tc.TelemeteringConfiguration?.EquipmentInfoId,
                            EquipmentInfoName = tc.TelemeteringConfiguration?.EquipmentInfo?.Name,
                            TelemetryConfiguration = ObjectMapper.Map<TelemeteringConfigurationProperty>(tc.TelemeteringConfiguration),
                            IsActive = tc.IsActive
                        }).ToList();
                    }
                    else
                    {
                        output.TelemetryConfigs = new List<SecondaryCircuitInspectionTelemetryConfigOutput>();
                    }
                    // 映射遥信配置关联
                    if (entity.TelesignalConfigs != null && entity.TelesignalConfigs.Any())
                    {
                        output.TelesignalConfigs = entity.TelesignalConfigs.Select(tc => new SecondaryCircuitInspectionTelesignalConfigOutput
                        {
                            Id = tc.Id,
                            SecondaryCircuitInspectionItemId = tc.SecondaryCircuitInspectionItemId,
                            TelesignalConfigurationId = tc.TelesignalConfigurationId ?? Guid.Empty,
                            TelesignalConfigurationName = tc.TelesignalisationConfiguration?.Name,
                            EquipmentInfoId = tc.TelesignalisationConfiguration?.EquipmentInfoId,
                            EquipmentInfoName = tc.TelesignalisationConfiguration?.EquipmentInfo?.Name,
                            TelesignalConfiguration = ObjectMapper.Map<TelesignalisationConfigurationProperty>(tc.TelesignalisationConfiguration),
                            IsActive = tc.IsActive
                        }).ToList();
                    }
                    else
                    {
                        output.TelesignalConfigs = new List<SecondaryCircuitInspectionTelesignalConfigOutput>();
                    }

                    outputList.Add(output);
                }

                rst.ResultData = outputList;
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                Log4Helper.Error(this.GetType(), "查询所有事件驱动配置（不分页）", ex);
            }
            return rst;
        }

        #endregion

        #region 删

        /// <summary>
        /// 删除事件驱动配置
        /// </summary>
        [HttpGet, Description("删除事件驱动配置")]
        [ShowApi]
        [AllowAnonymous]
        public async Task<RequestEasyResult> DeleteAsync(
            Guid id,
            CancellationToken cancellationToken = default)
        {
            var rst = new RequestEasyResult();
            try
            {
                var entity = await _eventDrivenConfigRepository.FirstOrDefaultAsync(u => u.Id == id).ConfigureAwait(false);
                if (entity == null)
                {
                    rst.Message = "事件驱动配置不存在";
                    return rst;
                }
                //var items = _inspectionEventItemRepository.GetAll().Where(t => t.InpectionEventDrivenId == id).Select(t=>t.Id);
                //if (items!=null&& items.Any())
                //{
                //    _inspectionEventItemRepository.BatchDeleteAsync(t=>);
                //    foreach (var item in items)
                //    {

                //    }
                //}
                await _eventDrivenConfigRepository.DeleteAsync(entity).ConfigureAwait(false);
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.ToString();
                Log4Helper.Error(this.GetType(), "删除事件驱动配置", ex);
            }
            return rst;
        }

        /// <summary>
        /// 批量删除事件驱动配置
        /// </summary>
        [HttpPost, Description("批量删除事件驱动配置")]
        [ShowApi]
        public async Task<RequestEasyResult> BatchDeleteAsync(
            List<Guid> ids,
            CancellationToken cancellationToken = default)
        {
            var rst = new RequestEasyResult();
            try
            {
                if (ids == null || !ids.Any())
                {
                    rst.Message = "请选择要删除的配置";
                    return rst;
                }

                var entities = await _eventDrivenConfigRepository.GetAll()
                    .Where(x => ids.Contains(x.Id))
                    .ToListAsync(cancellationToken);

                foreach (var entity in entities)
                {
                    await _eventDrivenConfigRepository.DeleteAsync(entity);
                }

                rst.Flag = true;
                rst.Message = $"成功删除 {entities.Count} 个事件驱动配置";
            }
            catch (Exception ex)
            {
                rst.Message = ex.ToString();
                Log4Helper.Error(this.GetType(), "批量删除事件驱动配置", ex);
            }
            return rst;
        }

        #endregion

        #region 其他操作

        /// <summary>
        /// 启用/禁用事件驱动配置
        /// </summary>
        [HttpPost, Description("启用/禁用事件驱动配置")]
        [ShowApi]
        public async Task<RequestEasyResult> SetActiveStatusAsync(
            Guid id,
            bool isActive,
            CancellationToken cancellationToken = default)
        {
            var rst = new RequestEasyResult();
            try
            {
                var entity = await _eventDrivenConfigRepository.FirstOrDefaultAsync(u => u.Id == id).ConfigureAwait(false);
                if (entity == null)
                {
                    rst.Message = "事件驱动配置不存在";
                    return rst;
                }
                entity.IsActive = isActive;
                await _eventDrivenConfigRepository.UpdateAsync(entity);

                rst.Flag = true;
                rst.Message = isActive ? "启用成功" : "禁用成功";
            }
            catch (Exception ex)
            {
                rst.Message = ex.ToString();
                Log4Helper.Error(this.GetType(), "启用/禁用事件驱动配置", ex);
            }
            return rst;
        }

        #endregion

        #region 事件驱动巡检项管理

        /// <summary>
        /// 获取事件驱动配置的巡检项列表
        /// </summary>
        [HttpPost, Description("获取事件驱动配置的巡检项列表")]
        [ShowApi]
        public async Task<RequestResult<List<SecondaryCircuitInspectionEventItemOutput>>> GetEventItemsAsync(
            Guid eventDrivenConfigId,
            CancellationToken cancellationToken = default)
        {
            var rst = new RequestResult<List<SecondaryCircuitInspectionEventItemOutput>>();
            try
            {
                var items = await _inspectionEventItemRepository.GetAll()
                    .Include(x => x.InspectionItem)
                    .Where(x => x.InpectionEventDrivenId == eventDrivenConfigId)
               
                    .ToListAsync(cancellationToken);

                rst.ResultData = ObjectMapper.Map<List<SecondaryCircuitInspectionEventItemOutput>>(items);
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                Log4Helper.Error(this.GetType(), "获取事件驱动配置的巡检项列表", ex);
            }
            return rst;
        }

        
        /// <summary>
        /// 删除事件驱动配置的巡检项
        /// </summary>
        [HttpPost, Description("删除事件驱动配置的巡检项")]
        [ShowApi]
        public async Task<RequestEasyResult> RemoveEventItemAsync(
            Guid eventItemId,
            CancellationToken cancellationToken = default)
        {
            var rst = new RequestEasyResult();
            try
            {
                await _inspectionEventItemRepository.DeleteAsync(eventItemId);
                await CurrentUnitOfWork.SaveChangesAsync();

                rst.Flag = true;
                rst.Message = "删除成功";
            }
            catch (Exception ex)
            {
                rst.Message = ex.ToString();
                Log4Helper.Error(this.GetType(), "删除事件驱动配置的巡检项", ex);
            }
            return rst;
        }

        #endregion

     

        #region 私有方法

      

       

       


       
        public RequestPageResult<SecondaryCircuitEventDrivenConfigOutput> FindDatas(PageSearchCondition<SecondaryCircuitEventDrivenConfigSearchInput> searchCondition)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region 辅助类

        /// <summary>
        /// 事件驱动巡检项输出DTO
        /// </summary>
        public class SecondaryCircuitInspectionEventItemOutput
        {
            public Guid Id { get; set; }
            public Guid? InpectionEventDrivenId { get; set; }
            public Guid? InspectionItemId { get; set; }
            public string InspectionItemName { get; set; }
            public int ExecutionOrder { get; set; }
            public bool IsActive { get; set; }
            public decimal WeightCoefficient { get; set; }
            public DateTime? LastExecutionTime { get; set; }
            public SecondaryCircuitInspectionResultStatus LastExecutionResult { get; set; }
            public string LastExecutionErrorMessage { get; set; }
            public int TotalExecutionCount { get; set; }
            public int SuccessExecutionCount { get; set; }
            public int AbnormalExecutionCount { get; set; }
            public int ErrorExecutionCount { get; set; }
            public long AverageExecutionDurationMs { get; set; }
        }

        #endregion
    }
}