xiaowei/DMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初步完成数据中心服务类

Browse Source
This commit is contained in:
David P.G
2025-09-02 20:28:29 +08:00
parent 5ce3825fa9
commit 5e19bad149
7 changed files with 882 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

241
DMS.Application/Interfaces/IDataCenterService.cs Normal file
View File

@@ -0,0 +1,241 @@
using DMS.Application.DTOs;
using DMS.Core.Models;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace DMS.Application.Interfaces;
/// <summary>
/// 定义数据管理相关的应用服务操作，负责管理所有的数据，包括设备、变量表和变量。
/// </summary>
public interface IDataCenterService
{
#region 设备管理
/// <summary>
/// 异步根据ID获取设备DTO。
/// </summary>
Task<DeviceDto> GetDeviceByIdAsync(int id);
/// <summary>
/// 异步获取所有设备DTO列表。
/// </summary>
Task<List<DeviceDto>> GetAllDevicesAsync();
/// <summary>
/// 异步创建一个新设备及其关联的变量表和菜单（事务性操作）。
/// </summary>
/// <param name="dto">包含设备、变量表和菜单信息的DTO。</param>
/// <returns>新创建设备的DTO。</returns>
Task<CreateDeviceWithDetailsDto> CreateDeviceWithDetailsAsync(CreateDeviceWithDetailsDto dto);
/// <summary>
/// 异步更新一个已存在的设备。
/// </summary>
Task<int> UpdateDeviceAsync(DeviceDto deviceDto);
/// <summary>
/// 异步删除一个设备。
/// </summary>
Task<bool> DeleteDeviceByIdAsync(int deviceId);
/// <summary>
/// 异步切换设备的激活状态。
/// </summary>
Task ToggleDeviceActiveStateAsync(int id);
/// <summary>
/// 在内存中添加设备
/// </summary>
void AddDeviceToMemory(DeviceDto deviceDto);
/// <summary>
/// 在内存中更新设备
/// </summary>
void UpdateDeviceInMemory(DeviceDto deviceDto);
/// <summary>
/// 在内存中删除设备
/// </summary>
void RemoveDeviceFromMemory(int deviceId);
#endregion
#region 变量表管理
/// <summary>
/// 异步根据ID获取变量表DTO。
/// </summary>
Task<VariableTableDto> GetVariableTableByIdAsync(int id);
/// <summary>
/// 异步获取所有变量表DTO列表。
/// </summary>
Task<List<VariableTableDto>> GetAllVariableTablesAsync();
/// <summary>
/// 异步创建一个新变量表及其关联菜单（事务性操作）。
/// </summary>
/// <param name="dto">包含变量表和菜单信息的DTO。</param>
/// <returns>新创建变量表的DTO。</returns>
Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto dto);
/// <summary>
/// 异步更新一个已存在的变量表。
/// </summary>
Task<int> UpdateVariableTableAsync(VariableTableDto variableTableDto);
/// <summary>
/// 异步删除一个变量表。
/// </summary>
Task<bool> DeleteVariableTableAsync(int id);
/// <summary>
/// 在内存中添加变量表
/// </summary>
void AddVariableTableToMemory(VariableTableDto variableTableDto);
/// <summary>
/// 在内存中更新变量表
/// </summary>
void UpdateVariableTableInMemory(VariableTableDto variableTableDto);
/// <summary>
/// 在内存中删除变量表
/// </summary>
void RemoveVariableTableFromMemory(int variableTableId);
#endregion
#region 变量管理
/// <summary>
/// 异步根据ID获取变量DTO。
/// </summary>
Task<VariableDto> GetVariableByIdAsync(int id);
/// <summary>
/// 异步获取所有变量DTO列表。
/// </summary>
Task<List<VariableDto>> GetAllVariablesAsync();
/// <summary>
/// 异步创建一个新变量（事务性操作）。
/// </summary>
Task<VariableDto> CreateVariableAsync(VariableDto variableDto);
/// <summary>
/// 异步更新一个已存在的变量（事务性操作）。
/// </summary>
Task<int> UpdateVariableAsync(VariableDto variableDto);
/// <summary>
/// 异步批量更新变量（事务性操作）。
/// </summary>
Task<int> UpdateVariablesAsync(List<VariableDto> variableDtos);
/// <summary>
/// 异步删除一个变量（事务性操作）。
/// </summary>
Task<bool> DeleteVariableAsync(int id);
/// <summary>
/// 异步批量删除变量（事务性操作）。
/// </summary>
Task<bool> DeleteVariablesAsync(List<int> ids);
/// <summary>
/// 异步批量导入变量。
/// </summary>
Task<bool> BatchImportVariablesAsync(List<VariableDto> variables);
/// <summary>
/// 检测一组变量是否已存在。
/// </summary>
/// <param name="variablesToCheck">要检查的变量列表。</param>
/// <returns>返回输入列表中已存在的变量。</returns>
Task<List<VariableDto>> FindExistingVariablesAsync(IEnumerable<VariableDto> variablesToCheck);
/// <summary>
/// 检测单个变量是否已存在。
/// </summary>
/// <param name="variableToCheck">要检查的变量。</param>
/// <returns>如果变量已存在则返回该变量，否则返回null。</returns>
Task<VariableDto?> FindExistingVariableAsync(VariableDto variableToCheck);
/// <summary>
/// 在内存中添加变量
/// </summary>
void AddVariableToMemory(VariableDto variableDto);
/// <summary>
/// 在内存中更新变量
/// </summary>
void UpdateVariableInMemory(VariableDto variableDto);
/// <summary>
/// 在内存中删除变量
/// </summary>
void RemoveVariableFromMemory(int variableId);
/// <summary>
/// 批量在内存中添加变量
/// </summary>
void AddVariablesToMemory(List<VariableDto> variables);
/// <summary>
/// 批量在内存中更新变量
/// </summary>
void UpdateVariablesInMemory(List<VariableDto> variables);
/// <summary>
/// 批量在内存中删除变量
/// </summary>
void RemoveVariablesFromMemory(List<int> variableIds);
#endregion
#region 数据存储访问
/// <summary>
/// 获取所有设备的安全字典。
/// </summary>
ConcurrentDictionary<int, DeviceDto> Devices { get; }
/// <summary>
/// 获取所有变量表的安全字典。
/// </summary>
ConcurrentDictionary<int, VariableTableDto> VariableTables { get; }
/// <summary>
/// 获取所有变量的安全字典。
/// </summary>
ConcurrentDictionary<int, VariableDto> Variables { get; }
#endregion
#region 数据加载和初始化
/// <summary>
/// 异步加载所有设备及其关联数据到内存中。
/// </summary>
Task LoadAllDataToMemoryAsync();
/// <summary>
/// 异步加载所有设备及其关联数据。
/// </summary>
Task<List<DeviceDto>> LoadAllDevicesAsync();
/// <summary>
/// 异步加载所有变量表及其关联数据。
/// </summary>
Task<List<VariableTableDto>> LoadAllVariableTablesAsync();
/// <summary>
/// 异步加载所有变量数据。
/// </summary>
Task<List<VariableDto>> LoadAllVariablesAsync();
#endregion
}

490
DMS.Application/Services/DataCenterService.cs Normal file
View File

@@ -0,0 +1,490 @@
using AutoMapper;
using DMS.Application.DTOs;
using DMS.Application.Interfaces;
using DMS.Core.Interfaces;
using DMS.Core.Models;
using DMS.Core.Enums;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
using System;
using System.Linq;
namespace DMS.Application.Services;
/// <summary>
/// 数据中心服务，负责管理所有的数据，包括设备、变量表和变量。
/// 实现 <see cref="IDataCenterService"/> 接口。
/// </summary>
public class DataCenterService : IDataCenterService
{
private readonly IRepositoryManager _repositoryManager;
private readonly IMapper _mapper;
private readonly IDeviceAppService _deviceAppService;
private readonly IVariableTableAppService _variableTableAppService;
private readonly IVariableAppService _variableAppService;
/// <summary>
/// 安全字典，用于存储所有设备数据
/// </summary>
public ConcurrentDictionary<int, DeviceDto> Devices { get; } = new();
/// <summary>
/// 安全字典，用于存储所有变量表数据
/// </summary>
public ConcurrentDictionary<int, VariableTableDto> VariableTables { get; } = new();
/// <summary>
/// 安全字典，用于存储所有变量数据
/// </summary>
public ConcurrentDictionary<int, VariableDto> Variables { get; } = new();
/// <summary>
/// 构造函数，通过依赖注入获取仓储管理器和相关服务实例。
/// </summary>
/// <param name="repositoryManager">仓储管理器实例。</param>
/// <param name="mapper">AutoMapper 实例。</param>
/// <param name="deviceAppService">设备应用服务实例。</param>
/// <param name="variableTableAppService">变量表应用服务实例。</param>
/// <param name="variableAppService">变量应用服务实例。</param>
public DataCenterService(
IRepositoryManager repositoryManager,
IMapper mapper,
IDeviceAppService deviceAppService,
IVariableTableAppService variableTableAppService,
IVariableAppService variableAppService)
{
_repositoryManager = repositoryManager;
_mapper = mapper;
_deviceAppService = deviceAppService;
_variableTableAppService = variableTableAppService;
_variableAppService = variableAppService;
}
#region 设备管理
/// <summary>
/// 异步根据ID获取设备DTO。
/// </summary>
public async Task<DeviceDto> GetDeviceByIdAsync(int id)
{
return await _deviceAppService.GetDeviceByIdAsync(id);
}
/// <summary>
/// 异步获取所有设备DTO列表。
/// </summary>
public async Task<List<DeviceDto>> GetAllDevicesAsync()
{
return await _deviceAppService.GetAllDevicesAsync();
}
/// <summary>
/// 异步创建一个新设备及其关联的变量表和菜单（事务性操作）。
/// </summary>
public async Task<CreateDeviceWithDetailsDto> CreateDeviceWithDetailsAsync(CreateDeviceWithDetailsDto dto)
{
return await _deviceAppService.CreateDeviceWithDetailsAsync(dto);
}
/// <summary>
/// 异步更新一个已存在的设备。
/// </summary>
public async Task<int> UpdateDeviceAsync(DeviceDto deviceDto)
{
return await _deviceAppService.UpdateDeviceAsync(deviceDto);
}
/// <summary>
/// 异步删除一个设备。
/// </summary>
public async Task<bool> DeleteDeviceByIdAsync(int deviceId)
{
return await _deviceAppService.DeleteDeviceByIdAsync(deviceId);
}
/// <summary>
/// 异步切换设备的激活状态。
/// </summary>
public async Task ToggleDeviceActiveStateAsync(int id)
{
await _deviceAppService.ToggleDeviceActiveStateAsync(id);
}
/// <summary>
/// 在内存中添加设备
/// </summary>
public void AddDeviceToMemory(DeviceDto deviceDto)
{
Devices.TryAdd(deviceDto.Id, deviceDto);
}
/// <summary>
/// 在内存中更新设备
/// </summary>
public void UpdateDeviceInMemory(DeviceDto deviceDto)
{
Devices.AddOrUpdate(deviceDto.Id, deviceDto, (key, oldValue) => deviceDto);
}
/// <summary>
/// 在内存中删除设备
/// </summary>
public void RemoveDeviceFromMemory(int deviceId)
{
Devices.TryRemove(deviceId, out _);
}
#endregion
#region 变量表管理
/// <summary>
/// 异步根据ID获取变量表DTO。
/// </summary>
public async Task<VariableTableDto> GetVariableTableByIdAsync(int id)
{
return await _variableTableAppService.GetVariableTableByIdAsync(id);
}
/// <summary>
/// 异步获取所有变量表DTO列表。
/// </summary>
public async Task<List<VariableTableDto>> GetAllVariableTablesAsync()
{
return await _variableTableAppService.GetAllVariableTablesAsync();
}
/// <summary>
/// 异步创建一个新变量表及其关联菜单（事务性操作）。
/// </summary>
public async Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto dto)
{
return await _variableTableAppService.CreateVariableTableAsync(dto);
}
/// <summary>
/// 异步更新一个已存在的变量表。
/// </summary>
public async Task<int> UpdateVariableTableAsync(VariableTableDto variableTableDto)
{
return await _variableTableAppService.UpdateVariableTableAsync(variableTableDto);
}
/// <summary>
/// 异步删除一个变量表。
/// </summary>
public async Task<bool> DeleteVariableTableAsync(int id)
{
return await _variableTableAppService.DeleteVariableTableAsync(id);
}
/// <summary>
/// 在内存中添加变量表
/// </summary>
public void AddVariableTableToMemory(VariableTableDto variableTableDto)
{
VariableTables.TryAdd(variableTableDto.Id, variableTableDto);
}
/// <summary>
/// 在内存中更新变量表
/// </summary>
public void UpdateVariableTableInMemory(VariableTableDto variableTableDto)
{
VariableTables.AddOrUpdate(variableTableDto.Id, variableTableDto, (key, oldValue) => variableTableDto);
}
/// <summary>
/// 在内存中删除变量表
/// </summary>
public void RemoveVariableTableFromMemory(int variableTableId)
{
VariableTables.TryRemove(variableTableId, out _);
}
#endregion
#region 变量管理
/// <summary>
/// 异步根据ID获取变量DTO。
/// </summary>
public async Task<VariableDto> GetVariableByIdAsync(int id)
{
return await _variableAppService.GetVariableByIdAsync(id);
}
/// <summary>
/// 异步获取所有变量DTO列表。
/// </summary>
public async Task<List<VariableDto>> GetAllVariablesAsync()
{
return await _variableAppService.GetAllVariablesAsync();
}
/// <summary>
/// 异步创建一个新变量（事务性操作）。
/// </summary>
public async Task<VariableDto> CreateVariableAsync(VariableDto variableDto)
{
return await _variableAppService.CreateVariableAsync(variableDto);
}
/// <summary>
/// 异步更新一个已存在的变量（事务性操作）。
/// </summary>
public async Task<int> UpdateVariableAsync(VariableDto variableDto)
{
return await _variableAppService.UpdateVariableAsync(variableDto);
}
/// <summary>
/// 异步批量更新变量（事务性操作）。
/// </summary>
public async Task<int> UpdateVariablesAsync(List<VariableDto> variableDtos)
{
return await _variableAppService.UpdateVariablesAsync(variableDtos);
}
/// <summary>
/// 异步删除一个变量（事务性操作）。
/// </summary>
public async Task<bool> DeleteVariableAsync(int id)
{
return await _variableAppService.DeleteVariableAsync(id);
}
/// <summary>
/// 异步批量删除变量（事务性操作）。
/// </summary>
public async Task<bool> DeleteVariablesAsync(List<int> ids)
{
return await _variableAppService.DeleteVariablesAsync(ids);
}
/// <summary>
/// 异步批量导入变量。
/// </summary>
public async Task<bool> BatchImportVariablesAsync(List<VariableDto> variables)
{
return await _variableAppService.BatchImportVariablesAsync(variables);
}
/// <summary>
/// 检测一组变量是否已存在。
/// </summary>
public async Task<List<VariableDto>> FindExistingVariablesAsync(IEnumerable<VariableDto> variablesToCheck)
{
return await _variableAppService.FindExistingVariablesAsync(variablesToCheck);
}
/// <summary>
/// 检测单个变量是否已存在。
/// </summary>
public async Task<VariableDto?> FindExistingVariableAsync(VariableDto variableToCheck)
{
return await _variableAppService.FindExistingVariableAsync(variableToCheck);
}
/// <summary>
/// 在内存中添加变量
/// </summary>
public void AddVariableToMemory(VariableDto variableDto)
{
Variables.TryAdd(variableDto.Id, variableDto);
}
/// <summary>
/// 在内存中更新变量
/// </summary>
public void UpdateVariableInMemory(VariableDto variableDto)
{
Variables.AddOrUpdate(variableDto.Id, variableDto, (key, oldValue) => variableDto);
}
/// <summary>
/// 在内存中删除变量
/// </summary>
public void RemoveVariableFromMemory(int variableId)
{
Variables.TryRemove(variableId, out _);
}
/// <summary>
/// 批量在内存中添加变量
/// </summary>
public void AddVariablesToMemory(List<VariableDto> variables)
{
foreach (var variable in variables)
{
Variables.TryAdd(variable.Id, variable);
}
}
/// <summary>
/// 批量在内存中更新变量
/// </summary>
public void UpdateVariablesInMemory(List<VariableDto> variables)
{
foreach (var variable in variables)
{
Variables.AddOrUpdate(variable.Id, variable, (key, oldValue) => variable);
}
}
/// <summary>
/// 批量在内存中删除变量
/// </summary>
public void RemoveVariablesFromMemory(List<int> variableIds)
{
foreach (var variableId in variableIds)
{
Variables.TryRemove(variableId, out _);
}
}
#endregion
#region 数据加载和初始化
/// <summary>
/// 异步加载所有设备及其关联数据到内存中。
/// </summary>
public async Task LoadAllDataToMemoryAsync()
{
try
{
// 清空现有数据
Devices.Clear();
VariableTables.Clear();
Variables.Clear();
// 加载所有设备
var devices = await _repositoryManager.Devices.GetAllAsync();
var deviceDtos = _mapper.Map<List<DeviceDto>>(devices);
// 加载所有变量表
var variableTables = await _repositoryManager.VariableTables.GetAllAsync();
var variableTableDtos = _mapper.Map<List<VariableTableDto>>(variableTables);
// 加载所有变量
var variables = await _repositoryManager.Variables.GetAllAsync();
var variableDtos = _mapper.Map<List<VariableDto>>(variables);
// 建立设备与变量表的关联
foreach (var deviceDto in deviceDtos)
{
deviceDto.VariableTables = variableTableDtos
.Where(vt => vt.DeviceId == deviceDto.Id)
.ToList();
// 将设备添加到安全字典
Devices.TryAdd(deviceDto.Id, deviceDto);
}
// 建立变量表与变量的关联
foreach (var variableTableDto in variableTableDtos)
{
variableTableDto.Variables = variableDtos
.Where(v => v.VariableTableId == variableTableDto.Id)
.ToList();
// 将变量表添加到安全字典
VariableTables.TryAdd(variableTableDto.Id, variableTableDto);
}
// 将变量添加到安全字典
foreach (var variableDto in variableDtos)
{
Variables.TryAdd(variableDto.Id, variableDto);
}
}
catch (Exception ex)
{
throw new ApplicationException($"加载所有数据到内存时发生错误,错误信息:{ex.Message}", ex);
}
}
/// <summary>
/// 异步加载所有设备及其关联数据。
/// </summary>
public async Task<List<DeviceDto>> LoadAllDevicesAsync()
{
try
{
// 获取所有设备
var devices = await _repositoryManager.Devices.GetAllAsync();
var deviceDtos = _mapper.Map<List<DeviceDto>>(devices);
// 为每个设备加载关联的变量表和变量
foreach (var deviceDto in deviceDtos)
{
// 获取设备的所有变量表
var variableTables = await _repositoryManager.VariableTables.GetAllAsync();
var deviceVariableTables = variableTables.Where(vt => vt.DeviceId == deviceDto.Id).ToList();
deviceDto.VariableTables = _mapper.Map<List<VariableTableDto>>(deviceVariableTables);
// 为每个变量表加载关联的变量
foreach (var variableTableDto in deviceDto.VariableTables)
{
var variables = await _repositoryManager.Variables.GetAllAsync();
var tableVariables = variables.Where(v => v.VariableTableId == variableTableDto.Id).ToList();
variableTableDto.Variables = _mapper.Map<List<VariableDto>>(tableVariables);
}
}
return deviceDtos;
}
catch (Exception ex)
{
throw new ApplicationException($"加载所有设备数据时发生错误,错误信息:{ex.Message}", ex);
}
}
/// <summary>
/// 异步加载所有变量表及其关联数据。
/// </summary>
public async Task<List<VariableTableDto>> LoadAllVariableTablesAsync()
{
try
{
// 获取所有变量表
var variableTables = await _repositoryManager.VariableTables.GetAllAsync();
var variableTableDtos = _mapper.Map<List<VariableTableDto>>(variableTables);
// 为每个变量表加载关联的变量
foreach (var variableTableDto in variableTableDtos)
{
var variables = await _repositoryManager.Variables.GetAllAsync();
var tableVariables = variables.Where(v => v.VariableTableId == variableTableDto.Id).ToList();
variableTableDto.Variables = _mapper.Map<List<VariableDto>>(tableVariables);
}
return variableTableDtos;
}
catch (Exception ex)
{
throw new ApplicationException($"加载所有变量表数据时发生错误,错误信息:{ex.Message}", ex);
}
}
/// <summary>
/// 异步加载所有变量数据。
/// </summary>
public async Task<List<VariableDto>> LoadAllVariablesAsync()
{
try
{
// 获取所有变量
var variables = await _repositoryManager.Variables.GetAllAsync();
return _mapper.Map<List<VariableDto>>(variables);
}
catch (Exception ex)
{
throw new ApplicationException($"加载所有变量数据时发生错误,错误信息:{ex.Message}", ex);
}
}
#endregion
}

143
DMS.Infrastructure.UnitTests/DataCenterServiceTests.cs Normal file
View File

@@ -0,0 +1,143 @@
using DMS.Application.DTOs;
using DMS.Application.Interfaces;
using DMS.Application.Services;
using DMS.Core.Interfaces;
using Moq;
using System.Collections.Concurrent;
using Xunit;
namespace DMS.Infrastructure.UnitTests
{
public class DataCenterServiceTests
{
[Fact]
public void DataCenterService_Should_Implement_All_Required_Methods()
{
// Arrange
var mockRepositoryManager = new Mock<IRepositoryManager>();
var mockMapper = new Mock<IMapper>();
var mockDeviceAppService = new Mock<IDeviceAppService>();
var mockVariableTableAppService = new Mock<IVariableTableAppService>();
var mockVariableAppService = new Mock<IVariableAppService>();
// Act
var dataCenterService = new DataCenterService(
mockRepositoryManager.Object,
mockMapper.Object,
mockDeviceAppService.Object,
mockVariableTableAppService.Object,
mockVariableAppService.Object);
// Assert - Verify that service implements the interface
Assert.IsAssignableFrom<IDataCenterService>(dataCenterService);
}
[Fact]
public void DataCenterService_Should_Have_ConcurrentDictionary_Properties()
{
// Arrange
var mockRepositoryManager = new Mock<IRepositoryManager>();
var mockMapper = new Mock<IMapper>();
var mockDeviceAppService = new Mock<IDeviceAppService>();
var mockVariableTableAppService = new Mock<IVariableTableAppService>();
var mockVariableAppService = new Mock<IVariableAppService>();
// Act
var dataCenterService = new DataCenterService(
mockRepositoryManager.Object,
mockMapper.Object,
mockDeviceAppService.Object,
mockVariableTableAppService.Object,
mockVariableAppService.Object);
// Assert
Assert.NotNull(dataCenterService.Devices);
Assert.NotNull(dataCenterService.VariableTables);
Assert.NotNull(dataCenterService.Variables);
Assert.IsType<ConcurrentDictionary<int, DeviceDto>>(dataCenterService.Devices);
Assert.IsType<ConcurrentDictionary<int, VariableTableDto>>(dataCenterService.VariableTables);
Assert.IsType<ConcurrentDictionary<int, VariableDto>>(dataCenterService.Variables);
}
[Fact]
public void DataCenterService_AddDeviceToMemory_Should_Add_Device_To_Dictionary()
{
// Arrange
var mockRepositoryManager = new Mock<IRepositoryManager>();
var mockMapper = new Mock<IMapper>();
var mockDeviceAppService = new Mock<IDeviceAppService>();
var mockVariableTableAppService = new Mock<IVariableTableAppService>();
var mockVariableAppService = new Mock<IVariableAppService>();
var dataCenterService = new DataCenterService(
mockRepositoryManager.Object,
mockMapper.Object,
mockDeviceAppService.Object,
mockVariableTableAppService.Object,
mockVariableAppService.Object);
var deviceDto = new DeviceDto { Id = 1, Name = "Test Device" };
// Act
dataCenterService.AddDeviceToMemory(deviceDto);
// Assert
Assert.True(dataCenterService.Devices.ContainsKey(1));
Assert.Equal(deviceDto, dataCenterService.Devices[1]);
}
[Fact]
public void DataCenterService_UpdateDeviceInMemory_Should_Update_Device_In_Dictionary()
{
// Arrange
var mockRepositoryManager = new Mock<IRepositoryManager>();
var mockMapper = new Mock<IMapper>();
var mockDeviceAppService = new Mock<IDeviceAppService>();
var mockVariableTableAppService = new Mock<IVariableTableAppService>();
var mockVariableAppService = new Mock<IVariableAppService>();
var dataCenterService = new DataCenterService(
mockRepositoryManager.Object,
mockMapper.Object,
mockDeviceAppService.Object,
mockVariableTableAppService.Object,
mockVariableAppService.Object);
var deviceDto = new DeviceDto { Id = 1, Name = "Test Device" };
var updatedDeviceDto = new DeviceDto { Id = 1, Name = "Updated Device" };
// Act
dataCenterService.AddDeviceToMemory(deviceDto);
dataCenterService.UpdateDeviceInMemory(updatedDeviceDto);
// Assert
Assert.True(dataCenterService.Devices.ContainsKey(1));
Assert.Equal(updatedDeviceDto, dataCenterService.Devices[1]);
Assert.Equal("Updated Device", dataCenterService.Devices[1].Name);
}
[Fact]
public void DataCenterService_RemoveDeviceFromMemory_Should_Remove_Device_From_Dictionary()
{
// Arrange
var mockRepositoryManager = new Mock<IRepositoryManager>();
var mockMapper = new Mock<IMapper>();
var mockDeviceAppService = new Mock<IDeviceAppService>();
var mockVariableTableAppService = new Mock<IVariableTableAppService>();
var mockVariableAppService = new Mock<IVariableAppService>();
var dataCenterService = new DataCenterService(
mockRepositoryManager.Object,
mockMapper.Object,
mockDeviceAppService.Object,
mockVariableTableAppService.Object,
mockVariableAppService.Object);
var deviceDto = new DeviceDto { Id = 1, Name = "Test Device" };
// Act
dataCenterService.AddDeviceToMemory(deviceDto);
dataCenterService.RemoveDeviceFromMemory(1);
// Assert
Assert.False(dataCenterService.Devices.ContainsKey(1));
}
}
}

2
DMS.Infrastructure/Services/OpcUaBackgroundService.cs
View File

@@ -64,7 +64,7 @@ public class OpcUaBackgroundService : BackgroundService
{ PollLevelType.ThirtyMinutes, TimeSpan.FromMilliseconds((int)PollLevelType.ThirtyMinutes) }
};
public OpcUaBackgroundService(IDeviceDataService deviceDataService, IDataProcessingService dataProcessingService, ILogger<OpcUaBackgroundService> logger)
public OpcUaBackgroundService(IDeviceDataService deviceDataService, IDataCenterService dataCenterService, IDataProcessingService dataProcessingService, ILogger<OpcUaBackgroundService> logger)
{
_deviceDataService = deviceDataService;
_dataProcessingService = dataProcessingService;

1
DMS.WPF/App.xaml.cs
View File

@@ -167,6 +167,7 @@ public partial class App : System.Windows.Application
services.AddSingleton<IDeviceAppService,DeviceAppService>();
services.AddSingleton<IVariableAppService,VariableAppService>();
services.AddSingleton<IVariableTableAppService,VariableTableAppService>();
services.AddSingleton<IDataCenterService, DataCenterService>();
services.AddSingleton<INavigationService, NavigationService>();
services.AddSingleton<IMenuService, MenuService>();
services.AddSingleton<IDialogService, DialogService>();

6
DMS.WPF/ViewModels/SplashViewModel.cs
View File

@@ -18,15 +18,17 @@ public partial class SplashViewModel : ObservableObject
{
private readonly IServiceProvider _serviceProvider;
private readonly IInitializeService _initializeService;
private readonly IDataCenterService _dataCenterService;
private readonly DataServices _dataServices;
[ObservableProperty]
private string _loadingMessage = "正在加载...";
public SplashViewModel(IServiceProvider serviceProvider, IInitializeService initializeService,DataServices dataServices)
public SplashViewModel(IServiceProvider serviceProvider, IInitializeService initializeService,IDataCenterService dataCenterService, DataServices dataServices)
{
_serviceProvider = serviceProvider;
_initializeService = initializeService;
this._dataCenterService = dataCenterService;
_dataServices = dataServices;
}
@@ -47,6 +49,8 @@ public partial class SplashViewModel : ObservableObject
await _dataServices.LoadVariables();
await _dataServices.LoadMenus();
await _dataCenterService.LoadAllDataToMemoryAsync();
_dataServices.AssociateVariableTablesToDevices();
_dataServices.AssociateVariablesToVariableTables();

6
DMS.sln
View File

@@ -24,8 +24,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DMS.Infrastructure.UnitTest
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DMS.WPF.UnitTests", "DMS.WPF.UnitTests\DMS.WPF.UnitTests.csproj", "{C15E6B39-211C-417A-BC3F-551AD17C8905}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpcUaTestApp", "OpcUaTestApp\OpcUaTestApp.csproj", "{FD58DDF1-340B-4946-28B7-5B905832858E}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -56,10 +54,6 @@ Global
{C15E6B39-211C-417A-BC3F-551AD17C8905}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C15E6B39-211C-417A-BC3F-551AD17C8905}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C15E6B39-211C-417A-BC3F-551AD17C8905}.Release|Any CPU.Build.0 = Release|Any CPU
{FD58DDF1-340B-4946-28B7-5B905832858E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{FD58DDF1-340B-4946-28B7-5B905832858E}.Debug|Any CPU.Build.0 = Debug|Any CPU
{FD58DDF1-340B-4946-28B7-5B905832858E}.Release|Any CPU.ActiveCfg = Release|Any CPU
{FD58DDF1-340B-4946-28B7-5B905832858E}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE