SOMS/src/YunDa.Application/YunDa.ISAS.Application/GeneralInformation/SecondaryCircuitInfo/SecondaryCircuitLogicExpressionAppService.cs

using Abp.Authorization;
using Abp.Domain.Entities;
using Abp.Domain.Repositories;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ToolLibrary.LogHelper;
using YunDa.ISAS.Application.Core;
using YunDa.ISAS.Application.Core.Configuration;
using YunDa.ISAS.Application.Core.Session;
using YunDa.ISAS.Application.Core.SwaggerHelper;
using YunDa.ISAS.DataTransferObject;
using YunDa.ISAS.Entities.DataMonitoring;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto.SearchCondition;
using YunDa.SOMS.DataTransferObject.GeneralInformation.SecondaryCircuitDto;
using YunDa.SOMS.Entities.GeneralInformation;
using static iText.StyledXmlParser.Jsoup.Select.Evaluator;
using static NetMQ.NetMQSelector;

namespace YunDa.ISAS.Application.GeneralInformation.SecondaryCircuitInfo
{
    /// <summary>
    /// 二次回路逻辑表达式类
    /// </summary>
    public class SecondaryCircuitLogicExpressionAppService : ISASAppServiceBase, ISecondaryCircuitLogicExpressionAppService
    {
        private readonly IRepository<SecondaryCircuit, Guid> _secondaryCircuitRepository;
        private readonly IRepository<SecondaryCircuitLogicExpression, Guid> _secondaryCircuitLogicExpressionRepository;
        private readonly IRepository<SecondaryCircuitProtectionDevice, Guid> _secondaryCircuitProtectionDeviceRepository;
        private readonly IRepository<TelemeteringConfiguration, Guid> _telemeteringConfigurationRepository;
        private readonly IRepository<TelesignalisationConfiguration, Guid> _telesignalisationConfigurationRepository;



        public SecondaryCircuitLogicExpressionAppService(ISessionAppService sessionAppService,
            IRepository<SecondaryCircuitLogicExpression, Guid> secondaryCircuitLogicExpressionRepository,
            IRepository<SecondaryCircuit, Guid> secondaryCircuitRepository,
            IRepository<SecondaryCircuitProtectionDevice, Guid> secondaryCircuitProtectionDeviceRepository,
            IRepository<TelemeteringConfiguration, Guid> telemeteringConfigurationRepository,
            IRepository<TelesignalisationConfiguration, Guid> telesignalisationConfigurationRepository,
        IAppServiceConfiguration appServiceConfiguration) : base(sessionAppService, appServiceConfiguration)
        {
            _secondaryCircuitLogicExpressionRepository = secondaryCircuitLogicExpressionRepository;
            _secondaryCircuitRepository = secondaryCircuitRepository;
            _secondaryCircuitProtectionDeviceRepository = secondaryCircuitProtectionDeviceRepository;
            _telemeteringConfigurationRepository = telemeteringConfigurationRepository;
            _telesignalisationConfigurationRepository = telesignalisationConfigurationRepository;
        }
        /// <summary>
        /// 添加或者修改二次回路的逻辑表达式
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [ShowApi]
        [AbpAllowAnonymous]
        public async Task<RequestResult<SecondaryCircuitLogicExpressionOutput>> CreateOrUpdateAsync(EditSecondaryCircuitLogicExpressionInput input)
        {
            RequestResult<SecondaryCircuitLogicExpressionOutput> result = new RequestResult<SecondaryCircuitLogicExpressionOutput>();
            try
            {
                SecondaryCircuitLogicExpression entity;
                if (input.Id.HasValue)
                {
                    // 更新逻辑
                    entity = await _secondaryCircuitLogicExpressionRepository.FirstOrDefaultAsync(input.Id.Value);
                    if (entity == null)
                    {
                        result.Message = "未找到该逻辑表达式记录";
                        result.Flag = false;
                        return result;
                    }
                    ObjectMapper.Map(input, entity);
                    entity.LastModificationTime = DateTime.Now;
                }
                else
                {
                    // 新建逻辑
                    entity = ObjectMapper.Map<SecondaryCircuitLogicExpression>(input);
                    entity.CreationTime = DateTime.Now;
                    var secondaryCircuitProtectionDevice = _secondaryCircuitProtectionDeviceRepository.GetAllIncluding(t => t.ProtectionDevice, t => t.ProtectionDevice.EquipmentInfo)
                    .Where(t => t.SecondaryCircuitId == input.SecondaryCircuitId).FirstOrDefault();
                    if (secondaryCircuitProtectionDevice != null)
                    {
                        int dispatchaddr = 1;
                        if (_telemeteringConfigurationRepository.GetAll().Where(t => t.DataSourceCategory == DataSourceCategoryEnum.None).Count()>0)
                        {
                            dispatchaddr =(int) _telemeteringConfigurationRepository.GetAll().Where(t => t.DataSourceCategory == DataSourceCategoryEnum.None)?.Select(t => t.DispatcherAddress)?.Max() + 1;
                        }
                        var telemetering = InsertTelemetering(secondaryCircuitProtectionDevice, entity.Name, dispatchaddr);
                        var telemeteringId = await _telemeteringConfigurationRepository.InsertAndGetIdAsync(telemetering);
                        if (telemeteringId!=default)
                        {
                            entity.TelemeteringConfigurationId = telemeteringId;
                        }
                        if (_telemeteringConfigurationRepository.GetAll().Where(t => t.DataSourceCategory == DataSourceCategoryEnum.None).Count()>0)
                        {
                            dispatchaddr = (int)_telemeteringConfigurationRepository.GetAll().Where(t => t.DataSourceCategory == DataSourceCategoryEnum.None)?.Select(t => t.DispatcherAddress)?.Max() + 1;
                        }

                        var telesignal = InsertTelesignal(secondaryCircuitProtectionDevice, entity.Name, dispatchaddr);
                        var telesignalId = await _telesignalisationConfigurationRepository.InsertAndGetIdAsync(telesignal);
                        if (telesignalId!= default)
                        {
                            entity.TelesignalisationConfigurationId = telesignalId;
                        }
                    }
                    await _secondaryCircuitLogicExpressionRepository.InsertAsync(entity);
                }
                result.ResultData = null;// ObjectMapper.Map<SecondaryCircuitLogicExpressionOutput>(entity);
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "CreateOrUpdate逻辑表达式", ex);
            }
            return result;
        }
        private TelemeteringConfiguration InsertTelemetering(SecondaryCircuitProtectionDevice secondaryCircuitProtectionDevice, string secondaryCircuitName, int dispatchaddr)
        {
            if (secondaryCircuitProtectionDevice!=null)
            {
                // 新增的记录
                var entity = new TelemeteringConfiguration();
                entity.DispatcherAddress = dispatchaddr;
                entity.CPUSector = 0;
                entity.DeviceAddress = 1;
                entity.InfoAddress = 0;
                entity.InfoCPUSector = 0;
                entity.InfoDeviceAddress = 1;
                entity.IsVirtualDevice = true;
                entity.IsSelfCheckingValue = false;
                entity.Name = $"{secondaryCircuitName}_判定遥测";
                entity.SeqNo = dispatchaddr;
                entity.IsActive = true;
                entity.IsSave = false;
                entity.IsSendDispatcher = false;
                entity.IsVisible = true;
                entity.UpperLimit = 10;
                entity.LowerLimit = 0;
                entity.DecimalDigits = 2;
                entity.Coefficient = 1;
                entity.Unit = "";
                entity.TransformerSubstationId = secondaryCircuitProtectionDevice.ProtectionDevice.TransformerSubstationId;
                entity.DataSourceCategory = DataSourceCategoryEnum.None;
                entity.EquipmentInfoId = secondaryCircuitProtectionDevice.ProtectionDevice.EquipmentInfoId;
                entity.EquipmentTypeId = secondaryCircuitProtectionDevice.ProtectionDevice.EquipmentInfo.EquipmentTypeId;
                return entity;
            }
            return null;
        }
        private TelesignalisationConfiguration InsertTelesignal(SecondaryCircuitProtectionDevice secondaryCircuitProtectionDevice, string secondaryCircuitName, int dispatchaddr)
        {
            // 新增的记录
            var entity = new TelesignalisationConfiguration
            {
                Name = $"{secondaryCircuitName}_判定虚遥信",
                DispatcherAddress = dispatchaddr,
                CPUSector = 0,
                DeviceAddress = 1,
                InfoAddress = 0,
                InfoCPUSector = 0,
                InfoDeviceAddress = 0,
                IsVirtualDevice = true,
                IsSelfCheckingValue = false,
                SeqNo = dispatchaddr,
                IsActive = true,
                IsSave = false,
                IsSendDispatcher = true,
                IsVisible = true,
                RemoteType  = RemoteTypeEnum.DoublePoint,
                YesContent = "故障",
                NoContent = "消失",
                UnsurenessContent = "不定",
                DataSourceCategory = DataSourceCategoryEnum.None,
                IsCommStatus = false,
                TransformerSubstationId = secondaryCircuitProtectionDevice.ProtectionDevice.TransformerSubstationId,
                EquipmentInfoId = secondaryCircuitProtectionDevice.ProtectionDevice.EquipmentInfoId,
                EquipmentTypeId = secondaryCircuitProtectionDevice.ProtectionDevice.EquipmentInfo.EquipmentTypeId,
            };
            return entity;
        }
        [HttpGet]
        [ShowApi]
        [AbpAllowAnonymous]
        public async Task<RequestEasyResult> DeleteByIdAsync(Guid id)
        {
            RequestEasyResult result = new RequestEasyResult();
            try
            {
                var entity = await _secondaryCircuitLogicExpressionRepository.FirstOrDefaultAsync(id);
                if (entity != null) 
                {
                   await _telesignalisationConfigurationRepository.DeleteAsync(entity.TelesignalisationConfigurationId.Value);
                   await _telemeteringConfigurationRepository.DeleteAsync(entity.TelemeteringConfigurationId.Value);
                }
                await _secondaryCircuitLogicExpressionRepository.DeleteAsync(id);
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "DeleteById逻辑表达式", ex);
            }
            return result;
        }
        /// <summary>
        /// 删除逻辑表达式
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        [HttpPost]
        [ShowApi]
        [AbpAllowAnonymous]
        public async Task<RequestEasyResult> DeleteByIdsAsync(List<Guid> ids)
        {
            RequestEasyResult result = new RequestEasyResult();
            try
            {
                foreach (var id in ids)
                {
                    var entity = await _secondaryCircuitLogicExpressionRepository.FirstOrDefaultAsync(id);
                    if (entity != null)
                    {
                        await _telesignalisationConfigurationRepository.DeleteAsync(entity.TelesignalisationConfigurationId.Value);
                        await _telemeteringConfigurationRepository.DeleteAsync(entity.TelemeteringConfigurationId.Value);
                    }
                    await _secondaryCircuitLogicExpressionRepository.DeleteAsync(id);
                }
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "DeleteByIds逻辑表达式", ex);
            }
            return result;
        }
        /// <summary>
        /// 查询逻辑表达式
        /// </summary>
        /// <param name="searchCondition"></param>
        /// <returns></returns>
        [HttpPost]
        [ShowApi]
        [AbpAllowAnonymous]
        public RequestPageResult<SecondaryCircuitLogicExpressionOutput> FindDatas(PageSearchCondition<SecondaryCircuitLogicExpressionSearchConditionInput> searchCondition)
        {
            RequestPageResult<SecondaryCircuitLogicExpressionOutput> result = new RequestPageResult<SecondaryCircuitLogicExpressionOutput>();
            try
            {
                var query = _secondaryCircuitLogicExpressionRepository.GetAllIncluding(x => x.TelemeteringConfiguration, x => x.TelesignalisationConfiguration);

                if (!string.IsNullOrWhiteSpace(searchCondition.SearchCondition.Name))
                {
                    query = query.Where(x => x.Name.Contains(searchCondition.SearchCondition.Name));
                }
                if (searchCondition.SearchCondition.SecondaryCircuitId.HasValue)
                {
                    query = query.Where(x => x.SecondaryCircuitId == searchCondition.SearchCondition.SecondaryCircuitId.Value);
                }
                if (searchCondition.SearchCondition.IsOnlyActive.HasValue)
                {
                    query = query.Where(x => x.IsActive == searchCondition.SearchCondition.IsOnlyActive.Value);
                }

                result.TotalCount = query.Count();

                var data = new List<SecondaryCircuitLogicExpression>();
                if (searchCondition.PageSize > 0)
                {
                    data = query.Skip((searchCondition.PageIndex - 1) * searchCondition.PageSize)
                                     .Take(searchCondition.PageSize)
                                     .ToList();
                }
                else
                {
                    data = query.ToList();
                }
                result.ResultData = ObjectMapper.Map<List<SecondaryCircuitLogicExpressionOutput>>(data);
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "FindDatas逻辑表达式", ex);
            }
            return result;
        }

    }
}