980 lines
46 KiB
C#
980 lines
46 KiB
C#
using Abp.Auditing;
|
|
using Abp.Authorization;
|
|
using Abp.Collections.Extensions;
|
|
using Abp.Domain.Repositories;
|
|
using Abp.Domain.Uow;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore.Diagnostics;
|
|
using MongoDB.Driver.Linq;
|
|
using Newtonsoft.Json;
|
|
using NPOI.SS.Formula.Functions;
|
|
using Swashbuckle.AspNetCore.SwaggerGen;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Linq.Dynamic.Core;
|
|
using System.Linq.Expressions;
|
|
using System.Security.Cryptography;
|
|
using System.Threading.Tasks;
|
|
using System.Xml.Serialization;
|
|
using ToolLibrary.LogHelper;
|
|
using YunDa.ISAS.Application.Core;
|
|
using YunDa.ISAS.Application.Core.Session;
|
|
using YunDa.ISAS.Application.Core.SwaggerHelper;
|
|
using YunDa.ISAS.DataTransferObject;
|
|
using YunDa.ISAS.DataTransferObject.CommonDto;
|
|
using YunDa.ISAS.DataTransferObject.GeneralInformation.EquipmentInfoDto.SearchCondition;
|
|
using YunDa.ISAS.Entities.GeneralInformation;
|
|
using YunDa.ISAS.Redis.Repositories;
|
|
using YunDa.ISMS.BASE.Entities.Models;
|
|
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto;
|
|
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto.HistoryData;
|
|
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto.SearchCondition;
|
|
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionSettingDto;
|
|
using YunDa.SOMS.Entities.GeneralInformation;
|
|
using static Google.Protobuf.Reflection.ExtensionRangeOptions.Types;
|
|
|
|
namespace YunDa.ISAS.Application.GeneralInformation
|
|
{
|
|
/// <summary>
|
|
/// 保护装置履历信息管理类
|
|
/// </summary>
|
|
public class ProtectionDeviceAppService : ISASAppServiceBase,IProtectionDeviceAppService
|
|
{
|
|
private readonly IRepository<EquipmentInfo, Guid> _equipmentInfoRepository;
|
|
private readonly IRepository<EquipmentType, Guid> _equipmentTypeRepository;
|
|
private readonly IRepository<ManufacturerInfo, Guid> _manufacturerInfoRepository;
|
|
private readonly IRepository<TransformerSubstation, Guid> _transformerSubstationRepository;
|
|
|
|
private readonly IRepository<ProtectionDeviceInfo, Guid> _protectionDeviceInfoRepository;
|
|
private readonly IRepository<ProtectionDeviceHistory, Guid> _protectionDeviceHistoryRepository;
|
|
private readonly IRepository<SecondaryCircuitProtectionDevice, Guid> _secondaryCircuitProtectionDeviceRepository;
|
|
private readonly IRepository<BoardCardInfo, Guid> _boardCardInfoRepository;
|
|
private readonly IRepository<BoardCardHistory, Guid> _boardCardHistoryRepository;
|
|
private readonly IRepository<ImProtectDevice,string> _imProtectDeviceRepository;
|
|
private readonly IRepository<ImGateWay, string> _imGateWayRepository;
|
|
private readonly IRepository<ImPuCtgy, string> _imPuCtgyRepository;
|
|
|
|
private readonly IRepository<ProtectionDeviceGateway, Guid> _protectionDeviceGatewayRepository;
|
|
private readonly IRepository<ProtectionDeviceType, Guid> _protectionDeviceTypeyRepository;
|
|
private readonly IRepository<ImDeviceDz, string> _imDeviceDzRepository;
|
|
private readonly IRedisRepository<ImDeviceDzOutput, string> _imDeviceDzRedis;
|
|
private readonly IUnitOfWorkManager _unitOfWorkManager;
|
|
|
|
public ProtectionDeviceAppService(
|
|
IRepository<ProtectionDeviceInfo, Guid> protectionDeviceInfoRepository,
|
|
IUnitOfWorkManager unitOfWorkManager,
|
|
IRepository<ImProtectDevice, string> imProtectDeviceRepository,
|
|
IRepository<EquipmentInfo, Guid> equipmentInfoRepository,
|
|
IRepository<SecondaryCircuitProtectionDevice, Guid> secondaryCircuitProtectionDeviceRepository
|
|
,
|
|
IRepository<ProtectionDeviceType, Guid> protectionDeviceTypeyRepository,
|
|
IRepository<ImPuCtgy, string> imPuCtgyRepository,
|
|
IRepository<ProtectionDeviceGateway, Guid> protectionDeviceGatewayRepository,
|
|
IRepository<ImGateWay, string> imGateWayRepository,
|
|
IRepository<BoardCardInfo, Guid> boardCardInfoRepository,
|
|
IRepository<BoardCardHistory, Guid> boardCardHistoryRepository,
|
|
IRepository<ProtectionDeviceHistory, Guid> protectionDeviceHistoryRepository,
|
|
IRepository<EquipmentType, Guid> equipmentTypeRepository,
|
|
IRepository<ManufacturerInfo, Guid> manufacturerInfoRepository,
|
|
IRepository<TransformerSubstation, Guid> transformerSubstationRepository,
|
|
IRepository<ImDeviceDz, string> imDeviceDzRepository,
|
|
ISessionAppService sessionAppService
|
|
) :
|
|
base(sessionAppService)
|
|
{
|
|
_unitOfWorkManager = unitOfWorkManager;
|
|
_equipmentInfoRepository = equipmentInfoRepository;
|
|
_imProtectDeviceRepository = imProtectDeviceRepository;
|
|
_protectionDeviceInfoRepository = protectionDeviceInfoRepository;
|
|
_protectionDeviceHistoryRepository = protectionDeviceHistoryRepository;
|
|
_boardCardInfoRepository = boardCardInfoRepository;
|
|
_boardCardHistoryRepository = boardCardHistoryRepository;
|
|
_secondaryCircuitProtectionDeviceRepository = secondaryCircuitProtectionDeviceRepository;
|
|
_imGateWayRepository = imGateWayRepository;
|
|
_protectionDeviceGatewayRepository = protectionDeviceGatewayRepository;
|
|
_imPuCtgyRepository = imPuCtgyRepository;
|
|
_protectionDeviceTypeyRepository = protectionDeviceTypeyRepository;
|
|
_equipmentTypeRepository = equipmentTypeRepository;
|
|
_manufacturerInfoRepository = manufacturerInfoRepository;
|
|
_transformerSubstationRepository = transformerSubstationRepository;
|
|
_imDeviceDzRepository = imDeviceDzRepository;
|
|
}
|
|
public async Task<RequestResult<ProtectionDeviceInfoViewOutput>> CreateOrUpdateAsync(EditProtectionDeviceInfoInput input)
|
|
{
|
|
RequestResult<ProtectionDeviceInfoViewOutput> rst = new RequestResult<ProtectionDeviceInfoViewOutput>();
|
|
try
|
|
{
|
|
if (input.Id.HasValue)
|
|
{
|
|
var entity = _protectionDeviceInfoRepository.GetAllIncluding(t=>t.EquipmentInfo).FirstOrDefault(t => t.Id == input.Id);
|
|
if (entity != null)
|
|
{
|
|
entity.LastModificationTime = DateTime.Now;
|
|
entity.LastModifierUserId = base.GetCurrentUser().Id;
|
|
entity.SeqNo = input.SeqNo;
|
|
// 逐字段赋值
|
|
entity.Name = input.Name;
|
|
entity.Specification = input.Specification;
|
|
entity.DeviceAddress = input.DeviceAddress;
|
|
entity.BaselineBoardVersion = input.BaselineBoardVersion;
|
|
entity.HardwareVersion = input.HardwareVersion;
|
|
entity.IsActive = input.IsActive;
|
|
// 设备信息赋值
|
|
if (entity.EquipmentInfo != null)
|
|
{
|
|
entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
|
|
entity.EquipmentInfo.Name = input.Name;
|
|
entity.EquipmentInfo.InstallationDate = input.InstallationDate;
|
|
entity.EquipmentInfo.ProductionDate = input.ProductionDate;
|
|
entity.EquipmentInfo.FactorySerialNumber = input.FactorySerialNumber;
|
|
entity.EquipmentInfo.VerificationPerson = input.VerificationPerson;
|
|
entity.EquipmentInfo.VerificationDate = input.VerificationDate;
|
|
entity.EquipmentInfo.VerificationRecords = input.VerificationRecords;
|
|
entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var entity = new ProtectionDeviceInfo();
|
|
entity.CreatorUserId = base.GetCurrentUser().Id;
|
|
entity.CreationTime = DateTime.Now;
|
|
// 逐字段赋值
|
|
entity.SeqNo = input.SeqNo;
|
|
entity.Name = input.Name;
|
|
entity.Specification = input.Specification;
|
|
entity.DeviceAddress = input.DeviceAddress;
|
|
entity.BaselineBoardVersion = input.BaselineBoardVersion;
|
|
entity.HardwareVersion = input.HardwareVersion;
|
|
entity.IsActive = input.IsActive;
|
|
entity.EquipmentInfo = new EquipmentInfo();
|
|
entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
|
|
entity.EquipmentInfo.SeqNo = input.SeqNo;
|
|
entity.EquipmentInfo.Name = input.Name;
|
|
entity.EquipmentInfo.InstallationDate = input.InstallationDate;
|
|
entity.EquipmentInfo.ProductionDate = input.ProductionDate;
|
|
entity.EquipmentInfo.FactorySerialNumber = input.FactorySerialNumber;
|
|
entity.EquipmentInfo.VerificationPerson = input.VerificationPerson;
|
|
entity.EquipmentInfo.VerificationDate = input.VerificationDate;
|
|
entity.EquipmentInfo.VerificationRecords = input.VerificationRecords;
|
|
entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
|
|
var equipmentInfoId =await _equipmentInfoRepository.InsertAndGetIdAsync(entity.EquipmentInfo);
|
|
entity.EquipmentInfoId = equipmentInfoId;
|
|
await _protectionDeviceInfoRepository.InsertAsync(entity);
|
|
}
|
|
rst.Flag = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "线路管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 扫码枪输入设备信息
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[HttpPost]
|
|
public RequestEasyResult ScanDeviceQRCode(EditProtectionQrCodeDeviceInfoInput input)
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
try
|
|
{
|
|
|
|
var repo = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo,t=>t.ProtectionDeviceType).ToList();
|
|
|
|
var protectionDevice = repo.FirstOrDefault(t => t.Name.Contains(input.Name));
|
|
if (protectionDevice != null)
|
|
{
|
|
//当出厂编号不一致进行履历更新
|
|
if (protectionDevice.EquipmentInfo.FactorySerialNumber != input.SerialNumber)
|
|
{
|
|
var json = JsonConvert.SerializeObject(protectionDevice);
|
|
var protectionDeviceHistory = _protectionDeviceHistoryRepository.GetAll().Where(t => t.ProtectionDeviceInfoId == protectionDevice.Id).ToList();
|
|
var deviceHistory = new ProtectionDeviceHistory
|
|
{
|
|
ContentJson = json,
|
|
CreationTime = DateTime.Now,
|
|
CreatorUserId = base.GetCurrentUser().Id,
|
|
Name = protectionDevice.Name,
|
|
RecodeDate = DateTime.Now,
|
|
ProtectionDeviceInfoId = protectionDevice.Id,
|
|
SeqNo = protectionDeviceHistory.Count > 0 ? protectionDeviceHistory.Max(t => t.SeqNo) : 1
|
|
};
|
|
protectionDevice.Specification = input.Specification;
|
|
protectionDevice.EquipmentInfo.FactorySerialNumber = input.SerialNumber;
|
|
protectionDevice.EquipmentInfo.ProductionDate = input.ProductionDate;
|
|
protectionDevice.EquipmentInfo.VerificationDate = input.VerificationDate;
|
|
protectionDevice.EquipmentInfo.VerificationPerson = input.VerificationPerson;
|
|
protectionDevice.EquipmentInfo.VerificationRecords = input.VerificationRecords;
|
|
var newjson = JsonConvert.SerializeObject(protectionDevice);
|
|
deviceHistory.ContentNewJson = newjson;
|
|
_protectionDeviceHistoryRepository.Insert(deviceHistory);
|
|
|
|
}
|
|
rst.Flag = true;
|
|
}
|
|
else
|
|
{
|
|
rst.Message = "未找到对应装置";
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw;
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
|
|
public async Task<RequestEasyResult> DeleteByIdAsync(Guid id)
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
return rst;
|
|
}
|
|
|
|
public async Task<RequestEasyResult> DeleteByIdsAsync(List<Guid> ids)
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
return rst;
|
|
}
|
|
/// <summary>
|
|
/// 查询保护装置信息
|
|
/// </summary>
|
|
/// <param name="searchCondition"></param>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[DisableAuditing]
|
|
[HttpPost]
|
|
public RequestPageResult<ProtectionDeviceInfoViewOutput> FindDatas(PageSearchCondition<ProtectionDeviceInfoSearchConditionInput> searchCondition)
|
|
{
|
|
RequestPageResult<ProtectionDeviceInfoViewOutput> rst = new RequestPageResult<ProtectionDeviceInfoViewOutput>();
|
|
|
|
try
|
|
{
|
|
var repo = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo)
|
|
.WhereIf(searchCondition.SearchCondition.IsOnlyActive.HasValue, t => t.IsActive)
|
|
.WhereIf(searchCondition.SearchCondition.Id.HasValue, t => t.Id == searchCondition.SearchCondition.Id.Value)
|
|
.WhereIf(searchCondition.SearchCondition.TransformerSubstationId.HasValue, t => t.Id == searchCondition.SearchCondition.TransformerSubstationId.Value).ToList();
|
|
List<ProtectionDeviceInfoViewOutput> datas = default;
|
|
if (!string.IsNullOrWhiteSpace( searchCondition.SearchCondition.Name))
|
|
{
|
|
repo = repo.Where(t => t.Name.Contains(searchCondition.SearchCondition.Name)).ToList();
|
|
}
|
|
rst.TotalCount = repo.Count();
|
|
if (repo.Count()>0)
|
|
{
|
|
rst.PageSize = searchCondition.PageSize;
|
|
rst.PageIndex = searchCondition.PageIndex;
|
|
if ( searchCondition.PageSize>0)
|
|
{
|
|
var dataTemps = repo.Skip((searchCondition.PageIndex-1)* searchCondition.PageSize).Take(searchCondition.PageSize);
|
|
datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(dataTemps);
|
|
}
|
|
else
|
|
{
|
|
datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(repo);
|
|
}
|
|
}
|
|
|
|
rst.ResultData= datas;
|
|
rst.Flag = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 查询保护装置信息
|
|
/// </summary>
|
|
/// <param name="searchCondition"></param>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[DisableAuditing]
|
|
[HttpPost]
|
|
public RequestPageResult<ProtectionDeviceInfoViewOutput> FindDatasByCircuit(PageSearchCondition<ProtectionDeviceInfoSearchConditionInput> searchCondition)
|
|
{
|
|
RequestPageResult<ProtectionDeviceInfoViewOutput> rst = new RequestPageResult<ProtectionDeviceInfoViewOutput>();
|
|
|
|
try
|
|
{
|
|
var repo = _secondaryCircuitProtectionDeviceRepository.GetAllIncluding(t => t.ProtectionDevice)
|
|
.Where(t=>t.SecondaryCircuitId == searchCondition.SearchCondition.SecondaryCircuitId).ToList();
|
|
List<ProtectionDeviceInfoViewOutput> datas = default;
|
|
|
|
rst.TotalCount = repo.Count();
|
|
if (repo.Count() > 0)
|
|
{
|
|
rst.PageSize = searchCondition.PageSize;
|
|
rst.PageIndex = searchCondition.PageIndex;
|
|
if (searchCondition.PageSize > 0)
|
|
{
|
|
var dataTemps = repo.Skip((searchCondition.PageIndex - 1) * searchCondition.PageSize).Take(searchCondition.PageSize);
|
|
datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(dataTemps.Select(t=>t.ProtectionDevice));
|
|
}
|
|
else
|
|
{
|
|
datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(repo);
|
|
}
|
|
}
|
|
|
|
rst.ResultData = datas;
|
|
rst.Flag = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 查询保护装置信息
|
|
/// </summary>
|
|
/// <param name="equipmentInfoId"></param>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[DisableAuditing]
|
|
[HttpGet]
|
|
public RequestResult<ProtectionDeviceInfoViewOutput> FindDataByEquipmentInfoId(Guid? equipmentInfoId)
|
|
{
|
|
RequestResult<ProtectionDeviceInfoViewOutput> rst = new RequestResult<ProtectionDeviceInfoViewOutput>();
|
|
|
|
try
|
|
{
|
|
var entity = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo,t=>t.EquipmentInfo.ManufacturerInfo)
|
|
.FirstOrDefault(t => t.EquipmentInfoId == equipmentInfoId);
|
|
if (entity!=null)
|
|
{
|
|
rst.ResultData = ObjectMapper.Map<ProtectionDeviceInfoViewOutput>(entity);
|
|
rst.Flag = true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 查询历史保护装置信息
|
|
/// </summary>
|
|
/// <param name="equipmentInfoId"></param>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[DisableAuditing]
|
|
[HttpGet]
|
|
public RequestResult<List<ProtectionDeviceHistoryOutput>> FindHistoryDataByEquipmentInfoId(Guid? equipmentInfoId)
|
|
{
|
|
RequestResult<List<ProtectionDeviceHistoryOutput>> rst = new RequestResult<List<ProtectionDeviceHistoryOutput>>();
|
|
try
|
|
{
|
|
List<ProtectionDeviceHistoryOutput> historys = new List<ProtectionDeviceHistoryOutput>();
|
|
var protectionDevice = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo)
|
|
.FirstOrDefault(t => t.EquipmentInfoId == equipmentInfoId);
|
|
if (protectionDevice != null)
|
|
{
|
|
var entitys = _protectionDeviceHistoryRepository.GetAll().Where(t => t.ProtectionDeviceInfoId == protectionDevice.Id);
|
|
foreach (var entity in entitys)
|
|
{
|
|
ProtectionDeviceInfo protectionDevice1= JsonConvert.DeserializeObject<ProtectionDeviceInfo>(entity.ContentJson);
|
|
ProtectionDeviceInfo protectionDevice2 = JsonConvert.DeserializeObject<ProtectionDeviceInfo>(entity.ContentNewJson);
|
|
ProtectionDeviceHistoryOutput historyOutput = new ProtectionDeviceHistoryOutput
|
|
{
|
|
SeqNo = entity.SeqNo,
|
|
RecodeDate = entity.RecodeDate,
|
|
PostUpdate = new ProtectionDeviceHistoryViewOutput
|
|
{
|
|
BaselineBoardVersion = protectionDevice1.BaselineBoardVersion,
|
|
FactorySerialNumber = protectionDevice1.EquipmentInfo.FactorySerialNumber,
|
|
ProductionDate = protectionDevice1.EquipmentInfo.ProductionDate,
|
|
HardwareVersion = protectionDevice1.HardwareVersion,
|
|
Specification = protectionDevice1.Specification,
|
|
VerificationDate = protectionDevice1.EquipmentInfo.VerificationDate,
|
|
VerificationPerson = protectionDevice1.EquipmentInfo.VerificationPerson,
|
|
VerificationRecords = protectionDevice1.EquipmentInfo.VerificationRecords,
|
|
},
|
|
PrioUpdate = new ProtectionDeviceHistoryViewOutput
|
|
{
|
|
BaselineBoardVersion = protectionDevice2.BaselineBoardVersion,
|
|
FactorySerialNumber = protectionDevice2.EquipmentInfo.FactorySerialNumber,
|
|
ProductionDate = protectionDevice2.EquipmentInfo.ProductionDate,
|
|
HardwareVersion = protectionDevice2.HardwareVersion,
|
|
Specification = protectionDevice2.Specification,
|
|
VerificationDate = protectionDevice2.EquipmentInfo.VerificationDate,
|
|
VerificationPerson = protectionDevice2.EquipmentInfo.VerificationPerson,
|
|
VerificationRecords = protectionDevice2.EquipmentInfo.VerificationRecords,
|
|
},
|
|
};
|
|
historys.Add(historyOutput);
|
|
|
|
}
|
|
rst.Flag = true;
|
|
rst.ResultData = historys;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
public RequestResult<string> GetProtectionDeviceQRcode(Guid id)
|
|
{
|
|
RequestResult<string> rst = new RequestResult<string>();
|
|
return rst;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取保护装置列表
|
|
/// </summary>
|
|
/// <param name="stationId"></param>
|
|
/// <returns></returns>
|
|
[HttpGet]
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[DisableAuditing]
|
|
public RequestResult<List<SelectModelOutput>> FindProtectionDeviceForSelect(Guid stationId)
|
|
{
|
|
var rst = new RequestResult<List<SelectModelOutput>> { Flag = false };
|
|
try
|
|
{
|
|
var datas = _protectionDeviceInfoRepository.GetAllIncluding()
|
|
.Where(e => e.IsActive)
|
|
.Where(t=>t.TransformerSubstationId == stationId)
|
|
.OrderBy(x=>x.SeqNo).ThenBy(x => x.Name);
|
|
|
|
rst.ResultData = datas.Select(item => new SelectModelOutput
|
|
{
|
|
Value = item.Id.ToString().ToLower(),
|
|
Key = item.Id,
|
|
Text = item.Name
|
|
}).ToList();
|
|
|
|
rst.Flag = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "获取保护装置列表", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
/// <summary>
|
|
/// 只在所内有效-获取变电所装置的ip地址
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpGet]
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[UnitOfWork(false)]
|
|
public RequestResult<List<ProtectionDeviceCommInfoOutput>> FindProtectionDeviceCommInfo(string stationName)
|
|
{
|
|
RequestResult<List<ProtectionDeviceCommInfoOutput>> rst = new RequestResult<List<ProtectionDeviceCommInfoOutput>>();
|
|
try
|
|
{
|
|
Dictionary<string, ProtectionDeviceInfo> porotectionDeviceInfos = default;
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
porotectionDeviceInfos = _protectionDeviceInfoRepository.GetAllIncluding().Where(t=>t.IsActive).ToDictionary(t => t.ISMS_DeviceId);
|
|
unitOfWork.Complete();
|
|
}
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
var devices = _imProtectDeviceRepository.GetAllIncluding(t => t.StatCodeNavigation, t => t.GateWay, t => t.PuctgyCodeNavigation).OrderBy(t => t.DeviceAddr);
|
|
List<ProtectionDeviceCommInfoOutput> datas = new List<ProtectionDeviceCommInfoOutput>();
|
|
foreach (var item in devices)
|
|
{
|
|
if (!porotectionDeviceInfos.ContainsKey(item.Id))
|
|
{
|
|
continue;
|
|
}
|
|
var deviceCommInfo = new ProtectionDeviceCommInfoOutput
|
|
{
|
|
EquipmentInfoName = porotectionDeviceInfos[item.Id].Name,
|
|
EquipmentInfoId = porotectionDeviceInfos[item.Id].EquipmentInfoId,
|
|
ProtectionDeviceId = porotectionDeviceInfos[item.Id].Id,
|
|
DeviceAddr = item.DeviceAddr,
|
|
DeviceName = item.DeviceName,
|
|
GatewayIP1 = item.GateWay.GatewayIp1,
|
|
GatewayIP2 = item.GateWay.GatewayIp2,
|
|
GatewayIP3 = "",
|
|
MaskEth1 = "255.255.255.0",
|
|
MaskEth2 = "255.255.255.0",
|
|
MaskEth3 = "255.255.255.0",
|
|
Gateway = "192.168.61.1",
|
|
Sntp1 = "192.168.61.99",
|
|
Sntp2 = "192.168.61.99",
|
|
IsZY = item.PuctgyCodeNavigation.PuctgyName.Contains("站域")
|
|
};
|
|
datas.Add(deviceCommInfo);
|
|
}
|
|
rst.ResultData = datas;
|
|
unitOfWork.Complete();
|
|
|
|
}
|
|
|
|
rst.Flag = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
|
|
}
|
|
return rst;
|
|
}
|
|
/// <summary>
|
|
/// 根据装置id获取装置通信参数
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpGet]
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[UnitOfWork(false)]
|
|
public async Task<RequestResult<ProtectionDeviceCommInfoOutput>> GetProtectionDeviceCommInfo(Guid deviceId,Guid equipmentId)
|
|
{
|
|
RequestResult<ProtectionDeviceCommInfoOutput> rst = new RequestResult<ProtectionDeviceCommInfoOutput>();
|
|
try
|
|
{
|
|
|
|
ProtectionDeviceInfo protectionDeviceInfo = null;
|
|
using (var work = _unitOfWorkManager.Begin())
|
|
{
|
|
if (deviceId == default)
|
|
{
|
|
protectionDeviceInfo = _protectionDeviceInfoRepository.GetAll().FirstOrDefault(t=>t.EquipmentInfoId == equipmentId);
|
|
}
|
|
else
|
|
{
|
|
protectionDeviceInfo = _protectionDeviceInfoRepository.Get(deviceId);
|
|
}
|
|
await work.CompleteAsync();
|
|
}
|
|
if (protectionDeviceInfo==null)
|
|
{
|
|
rst.Message = "传输id错误";
|
|
return rst;
|
|
}
|
|
ImProtectDevice device = null;
|
|
using (var work = _unitOfWorkManager.Begin())
|
|
{
|
|
device = _imProtectDeviceRepository.GetAllIncluding(t => t.StatCodeNavigation, t => t.GateWay).FirstOrDefault(t=>t.Id == protectionDeviceInfo.ISMS_DeviceId);
|
|
await work.CompleteAsync();
|
|
}
|
|
var deviceCommInfo = new ProtectionDeviceCommInfoOutput
|
|
{
|
|
DeviceAddr = device.DeviceAddr,
|
|
DeviceName = device.DeviceName,
|
|
GatewayIP1 = device.GateWay.GatewayIp1,
|
|
GatewayIP2 = device.GateWay.GatewayIp2,
|
|
GatewayIP3 = "",
|
|
MaskEth1 = "",
|
|
MaskEth2 = "",
|
|
MaskEth3 = "",
|
|
Gateway = "t192.168.61.1",
|
|
Sntp1 = "192.168.61.99",
|
|
Sntp2 = "192.168.61.99"
|
|
};
|
|
|
|
rst.ResultData = deviceCommInfo;
|
|
rst.Flag = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
|
|
}
|
|
return rst;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 从综自后台数据库迁移数据到运维数据库中（保护装置数据）
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[HttpGet]
|
|
[UnitOfWork(isTransactional: false)]
|
|
public RequestEasyResult MigreteDeviceEquipementDataFromISMS()
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
try
|
|
{
|
|
Dictionary<string,EquipmentInfo> equipments = default;
|
|
Dictionary<string, ImProtectDevice> imProtectDevices = default;
|
|
Dictionary<string, ProtectionDeviceInfo> porotectionDeviceInfos = default;
|
|
EquipmentType equipmentType = default;
|
|
ManufacturerInfo manufacturerInfo = default;
|
|
TransformerSubstation transformerSubstation = default;
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
transformerSubstation = _transformerSubstationRepository.GetAll().First();
|
|
equipments = _equipmentInfoRepository.GetAllIncluding().ToDictionary(t => t.Name);
|
|
equipmentType = _equipmentTypeRepository.GetAll().FirstOrDefault(t => t.Name.Contains("保护装置"));
|
|
manufacturerInfo = _manufacturerInfoRepository.GetAll().FirstOrDefault(t => t.ManufacturerName.Contains("运达"));
|
|
porotectionDeviceInfos = _protectionDeviceInfoRepository.GetAllIncluding().ToDictionary(t=>t.Name);
|
|
unitOfWork.Complete();
|
|
}
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
imProtectDevices = _imProtectDeviceRepository.GetAllIncluding().ToDictionary(t => t.DeviceName);
|
|
unitOfWork.Complete();
|
|
|
|
}
|
|
int count = 0;
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
foreach (var item in imProtectDevices.Keys)
|
|
{
|
|
var imProtectDevice = imProtectDevices[item];
|
|
Guid equipmentInfoId = default;
|
|
if (!equipments.ContainsKey(item))
|
|
{
|
|
var equipmentinfo = new EquipmentInfo
|
|
{
|
|
SeqNo = imProtectDevice.DeviceAddr,
|
|
TransformerSubstationId = transformerSubstation.Id,
|
|
CreationTime = DateTime.Now,
|
|
CreatorUserId = null,
|
|
IsActive = true,
|
|
EquipmentTypeId = equipmentType.Id,
|
|
ManufacturerInfoId = manufacturerInfo.Id,
|
|
Name = item
|
|
};
|
|
equipmentInfoId = _equipmentInfoRepository.InsertAndGetId(equipmentinfo);
|
|
}
|
|
else {
|
|
equipmentInfoId = equipments[item].Id;
|
|
}
|
|
if (!porotectionDeviceInfos.ContainsKey(item))
|
|
{
|
|
ProtectionDeviceInfo protectionDeviceInfo = new ProtectionDeviceInfo()
|
|
{
|
|
CanSwitchDZZone = imProtectDevice.CanSwDzzone == 1 ? true : false,
|
|
CreationTime = DateTime.Now,
|
|
CreatorUserId = null,
|
|
SupportsDualCurrent = imProtectDevice.SupportVersion,
|
|
BayName = imProtectDevice.BayName,
|
|
DeviceAddress = imProtectDevice.DeviceAddr,
|
|
DeviceState = imProtectDevice.DeviceState,
|
|
EndOfDKJL = imProtectDevice.EndOfDkjl,
|
|
EquipmentInfoId = equipmentInfoId,
|
|
IsActive = true,
|
|
ISMS_DeviceId = imProtectDevice.Id,
|
|
Name = item,
|
|
ProtectionDeviceGatewayId = null,
|
|
ProtectionDeviceTypeId = null,
|
|
TransformerSubstationId = transformerSubstation.Id,
|
|
};
|
|
_protectionDeviceInfoRepository.Insert(protectionDeviceInfo);
|
|
}
|
|
else
|
|
{
|
|
porotectionDeviceInfos[item].DeviceAddress = imProtectDevice.DeviceAddr;
|
|
}
|
|
}
|
|
unitOfWork.Complete();
|
|
}
|
|
rst.Flag = true;
|
|
rst.Message = $"共完成{count}信息迁移";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "线路管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
/// <summary>
|
|
/// 从综自后台数据库迁移数据到运维数据库中（保护装置类型数据）
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[HttpGet]
|
|
[UnitOfWork(isTransactional: false)]
|
|
public RequestEasyResult MigreteImProtectionDeviceTypeDataFromISMS()
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
try
|
|
{
|
|
Dictionary<string,ProtectionDeviceType> protectionDeviceTypes = default;
|
|
List<ImPuCtgy> imPuCtgies = default;
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
protectionDeviceTypes = _protectionDeviceTypeyRepository.GetAll().ToDictionary(t=>t.Name);
|
|
unitOfWork.Complete();
|
|
}
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
imPuCtgies = _imPuCtgyRepository.GetAll().ToList();
|
|
unitOfWork.Complete();
|
|
}
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
foreach (var imPuCtgie in imPuCtgies)
|
|
{
|
|
if (protectionDeviceTypes.ContainsKey(imPuCtgie.PuctgyName))
|
|
{
|
|
continue;
|
|
}
|
|
ProtectionDeviceType protectionDeviceType = new ProtectionDeviceType
|
|
{
|
|
CanSwitchDZZone = false,
|
|
CreationTime = DateTime.Now,
|
|
CreatorUserId = base.GetCurrentUser().Id,
|
|
DZZoneCount = imPuCtgie.DzzoneCount,
|
|
IsCRCC = true,
|
|
PUCtgyCode = 0,
|
|
Support12YC = false,
|
|
AnalogParseMode = imPuCtgie.AnalogParseMode,
|
|
DZReadOnly = false,
|
|
EventParseMode = imPuCtgie.EventParseMode,
|
|
IsActive = true,
|
|
ManufacturerInfoId = default,
|
|
Model = imPuCtgie.Model,
|
|
Name = imPuCtgie.PuctgyName,
|
|
Generation = imPuCtgie.Generation,
|
|
};
|
|
_protectionDeviceTypeyRepository.Insert(protectionDeviceType);
|
|
}
|
|
unitOfWork.Complete();
|
|
|
|
}
|
|
rst.Flag = true;
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "线路管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
/// <summary>
|
|
/// 从综自后台数据库迁移数据到运维数据库中（保护装置数据）
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[HttpGet]
|
|
[UnitOfWork(isTransactional: false)]
|
|
public RequestEasyResult MigreteImGatewayDataFromISMS()
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
try
|
|
{
|
|
Dictionary<string, ImProtectDevice> imProtectDevices = default;
|
|
Dictionary<string, ProtectionDeviceInfo> porotectionDeviceInfos = default;
|
|
//Dictionary<string, ImGateWay> imGateWays = default;
|
|
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
porotectionDeviceInfos = _protectionDeviceInfoRepository.GetAllIncluding(t=>t.EquipmentInfo).ToDictionary(t => t.Name);
|
|
unitOfWork.Complete();
|
|
}
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
imProtectDevices = _imProtectDeviceRepository.GetAllIncluding(t=>t.GateWay,t=>t.PuctgyCodeNavigation).ToDictionary(t => t.DeviceName);
|
|
unitOfWork.Complete();
|
|
|
|
}
|
|
int count = 0;
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
foreach (var device in imProtectDevices.Keys)
|
|
{
|
|
var porotectionDevice = porotectionDeviceInfos[device];
|
|
var imProtectDevice = imProtectDevices[device];
|
|
if (porotectionDevice != null)
|
|
{
|
|
ProtectionDeviceGateway protectionDeviceGateway = new ProtectionDeviceGateway
|
|
{
|
|
CreationTime = DateTime.Now,
|
|
CreatorUserId = base.GetCurrentUser().Id,
|
|
GatewayIP1 = imProtectDevice.GateWay.GatewayIp1,
|
|
GatewayIP2 = imProtectDevice.GateWay.GatewayIp2,
|
|
GatewayPort1 = imProtectDevice.GateWay.GatewayPort1,
|
|
GatewayPort2 = imProtectDevice.GateWay.GatewayPort2,
|
|
IsActive = true,
|
|
Name = imProtectDevice.GateWay.GateWayName,
|
|
PhysicalAddress = imProtectDevice.GateWay.PhyAddr,
|
|
Protocol = imProtectDevice.GateWay.Protocol,
|
|
TransformerSubstationId = porotectionDevice.TransformerSubstationId,
|
|
ProtectionDeviceInfoId = porotectionDevice.Id
|
|
};
|
|
ProtectionDeviceType protectionDeviceType = new ProtectionDeviceType
|
|
{
|
|
CanSwitchDZZone = false,
|
|
CreationTime = DateTime.Now,
|
|
CreatorUserId = base.GetCurrentUser().Id,
|
|
DZZoneCount = imProtectDevice.PuctgyCodeNavigation.DzzoneCount,
|
|
IsCRCC = true,
|
|
PUCtgyCode = imProtectDevice.PuctgyCode,
|
|
Support12YC = false,
|
|
AnalogParseMode = imProtectDevice.PuctgyCodeNavigation.AnalogParseMode,
|
|
DZReadOnly = false,
|
|
EventParseMode = imProtectDevice.PuctgyCodeNavigation.EventParseMode,
|
|
IsActive = true,
|
|
ManufacturerInfoId = porotectionDevice.EquipmentInfo.ManufacturerInfoId,
|
|
Model = imProtectDevice.PuctgyCodeNavigation.Model,
|
|
Name = imProtectDevice.PuctgyCodeNavigation.PuctgyName,
|
|
Generation = imProtectDevice.PuctgyCodeNavigation.Generation,
|
|
};
|
|
_protectionDeviceTypeyRepository.Insert(protectionDeviceType);
|
|
_protectionDeviceGatewayRepository.Insert(protectionDeviceGateway);
|
|
}
|
|
}
|
|
unitOfWork.Complete();
|
|
}
|
|
rst.Flag = true;
|
|
rst.Message = $"共完成{count}信息迁移";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rst.Message = ex.Message;
|
|
rst.Flag = false;
|
|
Log4Helper.Error(this.GetType(), "线路管理服务", ex);
|
|
}
|
|
|
|
return rst;
|
|
}
|
|
|
|
|
|
|
|
#if DEBUG
|
|
/// <summary>
|
|
/// 填充出厂编号
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[HttpGet]
|
|
public RequestEasyResult UpdateProtetionInfoForTest()
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
try
|
|
{
|
|
var datas = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo);
|
|
Random random = new Random();
|
|
foreach (var data in datas) {
|
|
|
|
data.BaselineBoardVersion = "v1.100.001";
|
|
data.Specification = "110V 1A";
|
|
data.EquipmentInfo.FactorySerialNumber = "210"+ random.Next(100000, 1000000).ToString();
|
|
// 设置出厂时间为当前日期的前一天（您可以根据需求调整时间）
|
|
data.EquipmentInfo.ProductionDate = DateTime.Now.AddDays(-100);
|
|
// 设置检验人员
|
|
data.EquipmentInfo.VerificationPerson = "贺严玲"; // 请替换为实际人员名称
|
|
// 设置检验日期为当前日期
|
|
data.EquipmentInfo.VerificationDate = DateTime.Now.AddDays(0).ToString("yyyy-MM-dd"); // 日期格式为 "yyyy-MM-dd"
|
|
// 设置检验记录内容
|
|
data.EquipmentInfo.VerificationRecords = "检验装置外观及功能，均符合要求";
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
throw;
|
|
}
|
|
return rst;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 填充出厂编号
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[ShowApi]
|
|
[AbpAllowAnonymous]
|
|
[HttpGet]
|
|
public async Task<RequestEasyResult> UpdateProtetionInfoForHistoryTest()
|
|
{
|
|
RequestEasyResult rst = new RequestEasyResult();
|
|
try
|
|
{
|
|
List<ProtectionDeviceInfo> datas;
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
datas = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo).ToList();
|
|
await unitOfWork.CompleteAsync();
|
|
}
|
|
Random random = new Random();
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
foreach (var data in datas)
|
|
{
|
|
EditProtectionQrCodeDeviceInfoInput deviceInfo = new EditProtectionQrCodeDeviceInfoInput
|
|
{
|
|
Name = data.Name, // 示例装置名称
|
|
SerialNumber = "210" + random.Next(100000, 1000000).ToString(), // 出厂编号设为 "210" 开头 + 6 位随机数
|
|
ProductionDate = new DateTime(2023, 5, 15), // 示例生产日期
|
|
VerificationPerson = "贺严玲", // 示例检验人员
|
|
VerificationDate = DateTime.Now.AddDays(-100+i).ToString("yyyy-MM-dd"), // 检验日期设为当前日期
|
|
VerificationRecords = "检验装置外观及功能，均符合要求" // 示例检验记录
|
|
};
|
|
using (var unitOfWork = _unitOfWorkManager.Begin())
|
|
{
|
|
ScanDeviceQRCode(deviceInfo);
|
|
await unitOfWork.CompleteAsync();
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
throw;
|
|
}
|
|
|
|
|
|
|
|
return rst;
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
}
|